U.S. patent application number 15/631603 was filed with the patent office on 2017-10-26 for customization of mobile applications using web-based technology.
The applicant listed for this patent is Facebook, Inc.. Invention is credited to Philip Fung, Yariv Sadan, Erick Tseng.
Application Number | 20170308279 15/631603 |
Document ID | / |
Family ID | 46236119 |
Filed Date | 2017-10-26 |
United States Patent
Application |
20170308279 |
Kind Code |
A1 |
Tseng; Erick ; et
al. |
October 26, 2017 |
Customization of Mobile Applications Using Web-Based Technology
Abstract
In one embodiment, receiving, at a first computing device from a
second computing device, a request for a view of a user interface
of a native application executing on the second computing device,
wherein the view includes one or more first user interface
components; determining, by the first computing device, a user
agent type of the second computing device; selecting, by the first
computing device, one or more second user-interface components to
be included in the view based on the user agent type of the second
computing device; generating, by the first computing device, code
implementing a structured document that represents the view,
wherein the structured document comprises the one or more first
user-interface components and the one or more second user-interface
components; and transmitting, from the first computing device to
the second computing device, the code.
Inventors: |
Tseng; Erick; (San
Francisco, CA) ; Fung; Philip; (San Francisco,
CA) ; Sadan; Yariv; (San Francisco, CA) |
|
Applicant: |
Name |
City |
State |
Country |
Type |
Facebook, Inc. |
Menlo Park |
CA |
US |
|
|
Family ID: |
46236119 |
Appl. No.: |
15/631603 |
Filed: |
June 23, 2017 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
14678917 |
Apr 3, 2015 |
9740670 |
|
|
15631603 |
|
|
|
|
12972262 |
Dec 17, 2010 |
9026905 |
|
|
14678917 |
|
|
|
|
Current U.S.
Class: |
1/1 |
Current CPC
Class: |
G06F 3/04847 20130101;
G06F 40/14 20200101; G06F 9/451 20180201; G06F 40/194 20200101;
G06F 40/103 20200101; H04L 67/42 20130101 |
International
Class: |
G06F 3/0484 20130101
G06F003/0484; G06F 17/22 20060101 G06F017/22; G06F 17/21 20060101
G06F017/21; H04L 29/06 20060101 H04L029/06; G06F 9/44 20060101
G06F009/44 |
Claims
1-20. (canceled)
21. A method comprising: receiving, at a client computing device, a
request to display a user interface of a native application
executing on the client computing device; sending, to a server
computing device from the client computing device, a request for
one or more first user-interface components of the user interface;
receiving, at the client computing device from the server computing
device, code implementing the one or more first user-interface
components of the user interface; accessing, by the client
computing device, one or more second user-interface components
based on a user agent type of the client computing device, the
second user-interface components associated with a native feature
of the client computing device, the native feature comprising a
hardware component of the client computing device; displaying, by
the client computing device, the one or more first user-interface
components and the one or more second user-interface
components.
22. The method of claim 21, wherein accessing the one or more
second user-interface components comprises receiving, from the
server computing device, the one or more second user-interface
components.
23. The method of claim 22, further comprising caching, on the
client computing device, the one or more second user-interface
components received from the server computing device.
23. The method of claim 21, wherein accessing the one or more
second user-interface components comprises accessing the one or
more second user-interface components from a memory of the client
computing device.
24. The method of claim 21, further comprising: receiving, at the
client computing device, user input resulting from a user
interaction with at least one of the displayed components;
determining, by the client computing device, whether to process the
user input at the client computing device or at the server
computing device.
25. The method of claim 24, further comprising: determining, by the
client computing device, whether processing or responding to the
user input will involve the native feature; when processing or
responding to the user input involves the native feature,
processing the user input at the client computing device; and when
processing or responding to the user input does not involve the
native feature, requesting, by the client computing device, a
server computing device to process the user input.
26. The method of claim 21, wherein the user agent type comprises
an identification of the native application.
27. The method of claim 21, wherein the hardware component
comprises a sensor native to the client computing device.
28. The method of claim 21, wherein the one or more first
user-interface components comprise components of a structured
document.
29. The method of claim 27, wherein the one or more second
user-interface components comprise components of a structured
document.
30. One or more non-transitory computer-readable storage media
embodying software that is operable when executed by a client
computing device to: receive a request to display a user interface
of a native application executing on the client computing device;
send, to a server computing device from the client computing
device, a request for one or more first user-interface components
of the user interface; receive code implementing the one or more
first user-interface components of the user interface; access one
or more second user-interface components based on a user agent type
of the client computing device, the second user-interface
components associated with a native feature of the client computing
device, the native feature comprising a hardware component of the
client computing device; provide for display the one or more first
user-interface components and the one or more second user-interface
components.
31. The media of claim 30, wherein the one or more second
user-interface components are provided from the server computing
device.
32. The media of claim 30, wherein the one or more second
user-interface components are accessed from a memory of the client
computing device.
33. The media of claim 30, wherein the user agent type comprises an
identification of the native application.
34. The media of claim 30, wherein the hardware component comprises
a sensor native to the client computing device.
35. A system comprising: one or more non-transitory
computer-readable storage media embodying instructions; one or more
processors coupled to the storage media and configured to execute
the instructions to: receive a request to display a user interface
of a native application executing on a client computing device;
send, to a server computing device from the client computing
device, a request for one or more first user-interface components
of the user interface; receive code implementing the one or more
first user-interface components of the user interface; access one
or more second user-interface components based on a user agent type
of the client computing device, the second user-interface
components associated with a native feature of the client computing
device, the native feature comprising a hardware component of the
client computing device; provide for display the one or more first
user-interface components and the one or more second user-interface
components.
36. The system of claim 35, wherein the one or more second
user-interface components are provided from the server computing
device.
37. The system of claim 35, wherein the one or more second
user-interface components are accessed from a memory of the client
computing device.
38. The system of claim 35, wherein the processors are further
configured to execute the instructions to: receive user input
resulting from a user interaction with at least one of the
displayed components; determine whether processing or responding to
the user input will involve the native feature; when processing or
responding to the user input involves the native feature, process
at least part of the user input; and when processing or responding
to the user input does not involve the native feature, request that
a server computing device process the user input.
39. The system of claim 35, wherein the user agent type comprises
an identification of the native application.
40. The system of claim 35, wherein the hardware component
comprises a sensor native to the client computing device.
Description
TECHNICAL FIELD
[0001] The present disclosure generally relates to customizing
native applications for mobile devices and more specifically
relates to implementing native applications for mobile devices that
do not require the user interfaces of the native applications to be
implemented entirely in native code.
BACKGROUND
[0002] Sophisticated mobile devices are able to support many
software applications. A mobile device, such as a tablet or netbook
computer, a smart phone (e.g., Apple iPhone and RIM BlackBerry), or
a personal digital assistant (PDA), usually has its own operating
system and a set of software applications that enables its user to
perform many activities. For example, with a mobile device having
the necessary software applications installed thereon, a user may
access web pages using a web browser application, read and send
emails using an email application, read and edit documents using a
word processor application, receive direction and location
information using a GPS application, and take digital photos using
a photo or imaging application.
SUMMARY
[0003] The present disclosure generally relates to customizing
native applications for mobile devices and more specifically
relates to implementing native applications for mobile devices that
do not require the user interfaces of the native applications to be
implemented entirely in native code.
[0004] In particular embodiments, receiving, at a first computing
device from a second computing device, a request for a view of a
user interface of a native application executing on the second
computing device, wherein the view includes one or more first user
interface components; determining, by the first computing device, a
user agent type of the second computing device; selecting, by the
first computing device, one or more second user-interface
components to be included in the view based on the user agent type
of the second computing device; generating, by the first computing
device, code implementing a structured document that represents the
view, wherein the structured document comprises the one or more
first user-interface components and the one or more second
user-interface components; and transmitting, from the first
computing device to the second computing device, the code.
[0005] These and other features, aspects, and advantages of the
disclosure are described in more detail below in the detailed
description and in conjunction with the following figures.
BRIEF DESCRIPTION OF THE DRAWINGS
[0006] FIG. 1 illustrates an example system for a native
application to have a web-based user interface.
[0007] FIG. 2 illustrates an example method for a native
application to have a web-based user interface.
[0008] FIG. 3 illustrates an example network environment.
[0009] FIG. 4 illustrates an example computer system.
[0010] FIG. 5 illustrates an example user interface.
DESCRIPTION OF EXAMPLE EMBODIMENTS
[0011] The present disclosure is now described in detail with
reference to a few embodiments thereof as illustrated in the
accompanying drawings. In the following description, numerous
specific details are set forth in order to provide a thorough
understanding of the present disclosure. However, the present
disclosure may be practiced without some or all of these specific
details. In other instances, well known process steps and/or
structures have not been described in detail in order not to
unnecessarily obscure the present disclosure. In addition, while
the disclosure is described in conjunction with the particular
embodiments, it should be understood that this description is not
intended to limit the disclosure to the described embodiments. To
the contrary, the description is intended to cover alternatives,
modifications, and equivalents as may be included within the spirit
and scope of the disclosure as defined by the appended claims.
[0012] In general, there are two types of software applications.
One type of software application may be referred to as "native
applications". Examples of the native applications may include
Microsoft Office Suite, Adobe Creative Suite, and Symantec Norton
360.TM.. Native applications are usually developed for specific
computing devices having specific operating systems and need to be
installed on the computing devices before they can be executed.
Often, a native application developed for one type of computing
device having one type of operating system cannot be readily
installed for execution on another type of computing device having
another type operating system. For example, a camera application
developed for the Motorola Droid mobile telephones with the Google
Android operating system may not be readily installed on an Apple
iPhone without some code modification. This is because such native
applications may have code that is platform dependent (i.e., native
code). Platform-dependent code depends on the specific programming
language features or libraries of a particular operating system or
specific hardware components or capabilities of a particular mobile
device. Consequently, native applications are platform dependent as
well, which means developers of a native application may need to
implement several versions of the same application for different
computing devices and different operating systems. The user
interface (UI) of a native application may have any number of
displayable views, and each view may include any number of UI
components. Each view may be individually displayed within the
context the native application.
[0013] In contrast, another type of software application may be
referred to as "web-based applications". Unlike native
applications, web-based applications are not installed locally on
the specific computing devices. Instead, a web-based application
usually executes on a remote server, which may be accessible to any
number of computing devices (i.e., client devices) simultaneously
via a network. Each web-based application may be hosted at a
particular website and has a unique Uniform Resource Locator (URL)
with which it may be accessed. Examples of the web-based
applications may include those applications located at
www.facebook.com, www.amazon.com, and www.expedia.com. The server
and the client devices may communicate using any suitable
communication protocol, such as Hypertext Transfer Protocol (HTTP).
Usually, the user interface of a web-based application is
implemented as a series of web pages, which may be loaded and
displayed in a web browser executing on a client device. The input
to the web-based application is received at the client device and
transmitted to the server for processing. The output of the
web-based application is transmitted from the server to the client
device to be displayed in the web browser. Because the web-based
applications mainly execute on the servers instead of on the
individual client devices (which host browser clients), they do not
depend on any software or hardware features of the specific client
devices. Therefore, they are not platform dependent. A web-based
application executing on a server may be accessible to different
types of client devices having different types of operating systems
and browser clients.
[0014] Both native applications and web-based applications have
certain disadvantages. For example, different versions of a native
application need to be implemented for different computing devices
and operating systems. On the other hand, there are certain
features or functionalities that cannot be supported by a web-based
application because they require native features provided by a
specific operating system or a specific device.
[0015] Particular embodiments provide a convenient way to develop
native applications by enabling a native application to incorporate
a web-based user interface. As a result, portions of the code
implementing the user interface of the native application does not
need to be written as native code (i.e., platform-dependent code).
Although different versions of the native application may still
need to be developed for different computing devices and operating
systems, a large segment of the user interface portion of the code
only needs to be implemented once and may be used with all versions
of the native application.
[0016] FIG. 1 illustrates an example system 100 for a native
application to incorporate a web-based user interface. In
particular embodiments, a computing device 110, such as a desktop
computer or a mobile device, has a native application 112 and a web
browser 111. In addition, in particular embodiments, computing
device 110 may also have an operation system (not shown). In
particular embodiments, computing device 110 may include hardware,
software, or embedded logic components or a combination of two or
more such components for carrying out the appropriate
functionalities implemented or supported by computing device 110.
In particular embodiments, native application 112 may be written in
any computing programming language and may be executed on computing
device 110. In particular embodiments, if computing devices has an
operation system, native application 112 may be executed within the
context of the operating system. In particular embodiments, a
server 120 has a UI library 121 that includes various UI-related
functions. In particular embodiments, server 120 may include
hardware, software, or embedded logic components or a combination
of two or more such components for carrying out the appropriate
functionalities implemented or supported by server 120. In
particular embodiments, UI library 121 may be implemented using any
suitable programming language, such as a server-side scripting
language (e.g., PHP). In particular embodiments, UI library 121 may
provide an application programming interface (API) so that its
functions may be invoked via API calls. In particular embodiments,
computing device 110 and server 120 may communicate with each other
via a computer network using any suitable communication protocol,
such as HTTP.
[0017] In particular embodiments, native application 112 has a user
interface, as FIG. 5 illustrates. In particular embodiments, at
least a portion of the code implementing the user interface of
native application 112 is not native code compiled for computing
device 110 and installed on computing device 110. Instead, in
particular embodiments, when selected portions of the user
interface of native application 112 are displayed, native
application 112 makes appropriate API calls to UI library 121
residing on server 120 to invoke the appropriate library functions
contained in UI library 121. Each API call may be transmitted from
computing device 110 to server 120 using any suitable communication
protocol, such as HTTP. In particular embodiments, upon receiving
an API call from computing device 110, UI library 121, or more
specifically, the functions invoked by the API call may generate
the appropriate code (i.e., UI code), such as code written in a
client-side scripting language that may be directly interpreted by
a web browser (e.g., HTML, XML, and/or JavaScript), that implements
all or a portion of the user interface of native application 112,
and transmits the UI code to computing device 110. Again, the UI
code may be transmitted from server 120 to computing device 110
using any suitable communication protocol, such as HTTP. Computing
device 110, after receiving the UI code from server 120, may load
the UI code in web browser 111. In particular embodiments, web
browser 111 may be executed and rendered within the context of
native application 112 so that the user interface of native
application 112 is rendered and displayed within the context of
native application 112. Alternatively, in particular embodiments,
native application 112 may include native code that is capable of
rendering the UI code received from server 120 to display the user
interface of native application 112 without the need of a separate
web browser (e.g., web browser 111).
[0018] FIG. 2 illustrates an example method for a native
application to have a web-based user interface. In particular
embodiments, some of the steps illustrated in FIG. 2 may be
performed by a client device (e.g., a mobile device) having an
operating system, a native application, and a web browser, and some
of the steps illustrated in FIG. 2 may be performed by a server
having a UI library.
[0019] In particular embodiments, a native application executing on
a client may need to display its user interface. The native
application, through the client, may transmit an API call to a
server having a UI library, as illustrated in STEP 211. The API
call may be in the form of a HTTP request that invokes an
appropriate function included in the UI library residing on the
server. In one implementation, the HTTP request includes a user
agent identifier that allows the server to identify the particular
application making the request in order to distinguish between a
standard browser client and the native application making the
request. In particular embodiments, the UI library, upon receiving
the API call, may generate appropriate code implementing the user
interface of the native application, as illustrated in STEP
221.
[0020] In particular embodiments, the user interface of the native
application may include any number of displayable views, and each
displayable view may be implemented, at least in part, as a web
page or other structured document. As FIG. 5 illustrates, for
example, the user interface may include a first portion 502 that is
natively rendered by the application by making appropriate calls
into the operating system, and additional portions 504, 506 that
may be browser-based renderings of structured documents returned by
a remote server. In particular embodiments, each web page may
include various UI components, such as icons 510, panels, menus,
text fields, check boxes, buttons 508, graphical components, etc.
In particular embodiments, each web page may include a standard set
of UI components that is the same regardless of on which platform
(e.g., the type of client and the operating system executing on the
client) the native application executes. In other words, this
standard set of UI components is platform independent. The standard
set of UI components may be selected based on the specification or
design requirements of the native application. When generating the
code for a web page, appropriate code is generated to implement
each UI component from the standard set of UI components.
[0021] In particular embodiments, in addition to the standard set
of UI components, a web page may also include a customized set of
UI components that may vary depending on the platform (e.g., the
type of client and the operating system executing on the client)
the native application executes. In other words, this optional,
customized set of UI components is platform dependent. For example,
if the native application executes on a mobile telephone that
includes a built-in camera, the web page may include a button that,
when clicked, causes a digital photograph to be taken by the
build-in camera included with the mobile telephone. In this case,
the customized set of UI components included in the web page may
include the camera button. On the other hand, if the native
application executes on a mobile telephone that does not include a
built-in camera, the camera button 508 may not be included in the
web page. In particular embodiments, the UI library may determine
the type of client device from which the API call is received and
select the customized set of UI components to be included in the
web page based on the device type of the client transmitting the
API call, as illustrated in STEP 221. When generating the code for
a web page, appropriate code is generated to implement each UI
component from the customized set of UI components, if any exists.
In one implementation, the server can decide which UI code to
include in a web page that responds to the request based on a user
agent identifier. For example, if the user agent identifies a
standard browser, then the server may not add code that would
render to a camera button; however, if the user agent identifies a
native application hosted on a mobile device, code for rendering a
camera button 508 on the phone may be included in the response.
Alternatively, in particular embodiments, the customized set of UI
components may be determined based on an identifier associated with
the request or the native application.
[0022] In particular embodiments, the code implementing the web
page that is a part of the user interface of the native application
(i.e., the UI code) may be written in a language that can be
directly interpreted and processed by a web browser, such as a
client-side scripting language (e.g., JavaScript), HTML, and/or
XML. In particular embodiments, the UI library, through the server,
may transmit the UI code to the client, as illustrated in STEP
222.
[0023] In particular embodiments, each UI component, whether
standard or customized, in the web page may be implemented as a
separate HTML element and includes an encoded clickable link or
region (e.g., an URL). In particular embodiments, the URL may be
customized for each individual UI component based on the
functionalities associated with that UI component. In particular
embodiments, a URL associated with a particular UI component may be
an URL referring to a resource on the server or may be a custom
URL. A custom uniform resource locator is a reference the native
application registers with the operating system. More specifically,
the custom uniform resource locator is operable, when processed by
a browser hosted on a client device 111, to launch the native
application. For example, a custom URL can comprise
"faceweb://facebook.com/home.php?control=camera" If such a standard
URL (e.g., http://www.facebook.com/places.php) is clicked by a
user, the corresponding resource on the server may be invoked. In
particular embodiments, each clickable URL may correspond to a
function in the UI library on the server or a link to a network
resource. If a user of the native application interacts with the UI
component by clicking on the component (activating its associated
URL), a HTTP request may be sent to the server to invoke the
library function or load the network resource corresponding to the
clicked URL. In particular embodiments, the HTTP request may
include any number of parameters specifically relevant to the UI
component that has been acted upon by the user. For example,
suppose the server is associated with the Facebook
social-networking system. A user click on a custom URL associated
with a particular UI component, however, may be intercepted and
handled by the native application. Still further, in some
implementations, the custom URL may be included in an embedded or
inline reference that causes the native application to intercept
the request on the initial page load, as opposed to a user click or
other activation, and call into the operating system to perform the
operation associated with the user interface control. In one
implementation, the native application registers a call back
function for all click events so that the native application can
intercept and filter onClick events. In some implementations, other
methods for distinguishing between URLs exists, such as encoding an
indicator in the parameter field of a standard URL that the native
application can recognize as a request to intercept and handle
locally.
[0024] Upon receiving the UI code from the server, the native
application may load the UI code in a web browser executing on the
client to display the user interface, as illustrated in STEP 212.
In particular embodiments, the web browser may be executed within
the context of the native application so that the web page, which
is a part of the user interface of the native application, is
rendered and displayed within the context of the native
application. Alternatively, in particular embodiments, the native
application may include code that is capable of processing the UI
code to render the web page for display within the context of the
native application. In this case, the native application in fact
implements the functionalities of a web browser so that it does not
require a separate web browser for processing the UI code to
display the web page.
[0025] In general, a user interface of an application, whether
native or web-based, enables its users to interact with the
application, such as providing input to the application and
receiving output from the application. This is achieved using
various UI components. For example, a user may provide text input
to an application through a text input field, or click a button or
a check box, or select a menu item, and so on. Each user action in
connection with a UI component may result in an event to be
generated. In particular embodiments, the native application may
monitor the events resulted from a user interacting with the
specific UI components included in each web page.
[0026] In particular embodiments, upon receiving a user input
resulted from a user of the native application interacting with one
of the UI components included in a web page, as illustrated in STEP
213, the native application may determine whether the user input
should be processed natively (i.e., locally at the client by the
native application itself), as illustrated in STEP 214. In
particular embodiments, a user input should be processed natively
if processing of and responding to the user input requires features
of functionalities only available at the client, such as library
functions provided by the operating system of the client or
hardware components included with the client. In other words, a
user input should be processed natively if processing of the user
input requires native code that is not generally available on a
server. For example, if the user clicks the camera button that
causes a digital photograph to be taken by the build-in camera of a
mobile telephone, the user input should be processed natively since
it requires the usage and functionalities of the build-in camera.
On the other hand, if the user submits a text message to be posted
on a blog, it is not necessary to process the user input natively
since it does not require any special features that are only
available through the operating system of the client or hardware
components included with the client. As discussed above, this
decisional step is aided by encoding the URLs that correspond to
the various UI elements with custom URL identifiers or other
parameters.
[0027] As described above, in particular embodiments, each web page
may include a standard set of UI components and optionally a
customized set of UI components. The standard set of UI components
is included in the web page regardless of the type of platform on
which the native application executes. Therefore, these standard UI
components are platform independent. The customized set of UI
components is selected based on the specific type of platform
(e.g., the hardware components and the operating system of the
client) on which the native application executes. Therefore, these
customized UI components are platform dependent. In particular
embodiments, if a user input results from the user interacting with
a standard UI component, the user input does not need to be
processed natively at the client and may be processed at the
server. If a user input results from the user interacting with a
customized UI component, the user input needs to be processed
natively at the client (e.g., by the native application
itself).
[0028] In particular embodiments, if the user input needs to be
processed natively (STEP 214-YES), then the native application
processes the input at the client (e.g., with native code included
with the native application), as illustrated in STEP 215. For
example, if a user clicks on a camera button, the native
application intercepts the request and makes calls to the operating
system to launch a camera application and interface. On the other
hand, if the user input may be processed at the server (STEP
214-NO), then the native application transmits the user input to
the server for processing, as illustrated in STEP 216. The server,
upon receiving the user input, may process it accordingly, as
illustrated in STEP 223.
[0029] In particular embodiments, when a user input is transmitted
to the server to be processed as a HTTP request, the HTTP request
may include various parameters or arguments that are specifically
relevant to the UI component being acted upon by the user. For
example, the HTTP request may include an API call to the UI
library. The server may parse the HTTP request to extract the API
call, and then forward the API call to the UI library to invoke the
corresponding function. Similarly, the custom URL that corresponds
to a native UI component function may also include one or more
parameters that the native application may use, such as including
the parameters with an API call to the native operating system.
[0030] In particular embodiments, the steps illustrated in FIG. 2
may be repeated as needed so that different web pages of the user
interface may be rendered and displayed on the client and different
user inputs may be processed. For example, a user input may cause
the current view of the user interface to change to another view.
In this case, a second request may be transmitted from the client
to the server for the new view of the user interface. The server
may generate code implementing a second web page representing the
new view and transmit the code to the client to be loaded in the
web browser so that the second web page may be displayed within the
context of the native application. By having the code implementing
the user interface of the native application generated at the
server, the user interface of the native application does not need
to be implemented with native code. Consequently, the same version
of the code implementing the user interface of the native
application may be used with different versions of the native
application for different platforms.
[0031] In particular embodiments, the client may cache locally some
of the information relevant to the native application. For example,
the client may cache some of the web page code (e.g., JavaScript or
HTML code) generated by the server so that it may be loaded
directly into the web browser when needed without having to request
for the code from the server again. In particular embodiments, the
client may pre-fetch some of the code implementing the user
interface of the native application to improve the performance of
the native application.
[0032] In particular embodiments, the method illustrated in FIG. 2
may be incorporated with a web-based application that implements a
social-networking system. A social network, in general, is a social
structure made up of entities, such as individuals or
organizations, that are connected by one or more types of
interdependency or relationships, such as friendship, kinship,
common interest, financial exchange, dislike, or relationships of
beliefs, knowledge, or prestige. In more recent years, social
networks have taken advantage of the Internet. There are
social-networking systems existing on the Internet in the form of
social-networking websites. Such social-networking websites enable
their members, who are commonly referred to as website users, to
perform various social activities. For example, the
social-networking website operated by Facebook, Inc. at
"www.facebook.com" enables its users to communicate with their
friends via emails, instant messages, or blog postings, organize
social events, share photos, receive news of their friends or
interesting events, play games, etc.
[0033] Users of a social-networking system may access the
corresponding social-networking website via their associated client
devices. In particular embodiments, if a user's client device has
special features that are not generally available through the
social-networking system, such as a built-in digital camera that
can take digital photographs and upload these digital photographs
to the social-networking system, a built-in or attached webcam that
can take digital videos or provide video conferencing, or an audio
recorder that can record digital audios, the UI components
supporting these native features may be included in the individual
web pages of the user interface of the social-networking system. If
the user interacts with such a UI component to use a native
feature, the user input may be intercepted and processed by a
native application residing on the client device, instead of being
transmitted to the server where the social-networking system
resides. Other native features can also be accessed, such as a
local file system, camera, native geo-location information, address
book contacts, and the like.
[0034] Furthermore, in one implementation, the web pages returned
to the native applications, when processed, can also cause the
native applications to perform one or more operations independent
of user clicks. For example, the custom URLs can be embedded as
in-line references, that when processed by a browser component
automatically generate outgoing requests that are intercepted by
the native application and processed. In this manner, the web
server via a structured document can make calls into a native
application hosted on a client device, such as a mobile phone. For
example, the web page may include a custom URL that causes the
native application to download a file (identified in the parameter
string of the URL) and store it as a file in the file system of the
client device. Similar commands can be used to later access the
stored file as well.
[0035] Particular embodiments may be implemented in a network
environment. FIG. 3 illustrates an example network environment 300
suitable for providing software validation as a service. Network
environment 300 includes a network 310 coupling one or more servers
320 and one or more clients 330 to each other. In particular
embodiments, network 310 is an intranet, an extranet, a virtual
private network (VPN), a local area network (LAN), a wireless LAN
(WLAN), a wide area network (WAN), a metropolitan area network
(MAN), a portion of the Internet, or another network 310 or a
combination of two or more such networks 310. The present
disclosure contemplates any suitable network 310.
[0036] One or more links 350 couple a server 320 or a client 330 to
network 310. In particular embodiments, one or more links 350 each
includes one or more wireline, wireless, or optical links 350. In
particular embodiments, one or more links 350 each includes an
intranet, an extranet, a VPN, a LAN, a WLAN, a WAN, a MAN, a
portion of the Internet, or another link 350 or a combination of
two or more such links 350. The present disclosure contemplates any
suitable links 350 coupling servers 320 and clients 330 to network
310.
[0037] In particular embodiments, each server 320 may be a unitary
server or may be a distributed server spanning multiple computers
or multiple datacenters. Servers 320 may be of various types, such
as, for example and without limitation, web server, news server,
mail server, message server, advertising server, file server,
application server, exchange server, database server, or proxy
server. In particular embodiments, each server 320 may include
hardware, software, or embedded logic components or a combination
of two or more such components for carrying out the appropriate
functionalities implemented or supported by server 320. For
example, a web server is generally capable of hosting websites
containing web pages or particular elements of web pages. More
specifically, a web server may host HTML files or other file types,
or may dynamically create or constitute files upon a request, and
communicate them to clients 330 in response to HTTP or other
requests from clients 330. A mail server is generally capable of
providing electronic mail services to various clients 330. A
database server is generally capable of providing an interface for
managing data stored in one or more data stores.
[0038] In particular embodiments, a server 320 may include a UI
library 322. In particular embodiments, UI library 322 may include
various functions and be implemented using any suitable programming
language. In particular embodiments, UI library 322 may implement
some of the steps illustrated in FIG. 2.
[0039] In particular embodiments, one or more data storages 340 may
be communicatively linked to one or more severs 320 via one or more
links 350. In particular embodiments, data storages 340 may be used
to store various types of information. In particular embodiments,
the information stored in data storages 340 may be organized
according to specific data structures. In particular embodiment,
each data storage 340 may be a relational database. Particular
embodiments may provide interfaces that enable servers 320 or
clients 330 to manage, e.g., retrieve, modify, add, or delete, the
information stored in data storage 340.
[0040] In particular embodiments, each client 330 may be an
electronic device including hardware, software, or embedded logic
components or a combination of two or more such components and
capable of carrying out the appropriate functionalities implemented
or supported by client 330. For example and without limitation, a
client 330 may be a desktop computer system, a notebook computer
system, a netbook computer system, a handheld electronic device, or
a mobile telephone. The present disclosure contemplates any
suitable clients 330. A client 330 may enable a network user at
client 330 to access network 330. A client 330 may enable its user
to communicate with other users at other clients 330.
[0041] A client 330 may have a web browser 332, such as MICROSOFT
INTERNET EXPLORER, GOOGLE CHROME or MOZILLA FIREFOX, and may have
one or more add-ons, plug-ins, or other extensions, such as TOOLBAR
or YAHOO TOOLBAR. A user at client 330 may enter a Uniform Resource
Locator (URL) or other address directing the web browser 332 to a
server 320, and the web browser 332 may generate a Hyper Text
Transfer Protocol (HTTP) request and communicate the HTTP request
to server 320. Server 320 may accept the HTTP request and
communicate to client 330 one or more Hyper Text Markup Language
(HTML) files responsive to the HTTP request. Client 330 may render
a web page based on the HTML files from server 320 for presentation
to the user. The present disclosure contemplates any suitable web
page files. As an example and not by way of limitation, web pages
may render from HTML files, Extensible Hyper Text Markup Language
(XHTML) files, or Extensible Markup Language (XML) files, according
to particular needs. Such pages may also execute scripts such as,
for example and without limitation, those written in JAVASCRIPT,
JAVA, MICROSOFT SILVERLIGHT, combinations of markup language and
scripts such as AJAX (Asynchronous JAVASCRIPT and XML), and the
like. Herein, reference to a web page encompasses one or more
corresponding web page files (which a browser may use to render the
web page) and vice versa, where appropriate.
[0042] In particular embodiments, a client 330 may include a native
application 334. In particular embodiments, native application 334
may be implemented using any suitable programming language. In
particular embodiments, native application 334 may include a user
interface that is not implemented using native code. Instead, the
code implementing the user interface of native application 334 is
generated by UI library 322 and transmitted to native application
334 when needed. Native application 334 loads the code received
from UI library 322 in web browser 332, which is executed within
the context of native application 334, so that the corresponding
displayable view of its user interface may be displayed within the
context of native application 334. In particular embodiments,
native application 334 may implement some of the steps illustrated
in FIG. 2.
[0043] Particular embodiments may be implemented on one or more
computer systems. FIG. 4 illustrates an example computer system
400. In particular embodiments, one or more computer systems 400
perform one or more steps of one or more methods described or
illustrated herein. In particular embodiments, one or more computer
systems 400 provide functionality described or illustrated herein.
In particular embodiments, software running on one or more computer
systems 400 performs one or more steps of one or more methods
described or illustrated herein or provides functionality described
or illustrated herein. Particular embodiments include one or more
portions of one or more computer systems 400.
[0044] This disclosure contemplates any suitable number of computer
systems 400. This disclosure contemplates computer system 400
taking any suitable physical form. As example and not by way of
limitation, computer system 400 may be an embedded computer system,
a system-on-chip (SOC), a single-board computer system (SBC) (such
as, for example, a computer-on-module (COM) or system-on-module
(SOM)), a desktop computer system, a laptop or notebook computer
system, an interactive kiosk, a mainframe, a mesh of computer
systems, a mobile telephone, a personal digital assistant (PDA), a
server, or a combination of two or more of these. Where
appropriate, computer system 400 may include one or more computer
systems 400; be unitary or distributed; span multiple locations;
span multiple machines; or reside in a cloud, which may include one
or more cloud components in one or more networks. Where
appropriate, one or more computer systems 400 may perform without
substantial spatial or temporal limitation one or more steps of one
or more methods described or illustrated herein. As an example and
not by way of limitation, one or more computer systems 400 may
perform in real time or in batch mode one or more steps of one or
more methods described or illustrated herein. One or more computer
systems 400 may perform at different times or at different
locations one or more steps of one or more methods described or
illustrated herein, where appropriate.
[0045] In particular embodiments, computer system 400 includes a
processor 402, memory 404, storage 406, an input/output (I/O)
interface 408, a communication interface 410, and a bus 412.
Although this disclosure describes and illustrates a particular
computer system having a particular number of particular components
in a particular arrangement, this disclosure contemplates any
suitable computer system having any suitable number of any suitable
components in any suitable arrangement.
[0046] In particular embodiments, processor 402 includes hardware
for executing instructions, such as those making up a computer
program. As an example and not by way of limitation, to execute
instructions, processor 402 may retrieve (or fetch) the
instructions from an internal register, an internal cache, memory
404, or storage 406; decode and execute them; and then write one or
more results to an internal register, an internal cache, memory
404, or storage 406. In particular embodiments, processor 402 may
include one or more internal caches for data, instructions, or
addresses. The present disclosure contemplates processor 402
including any suitable number of any suitable internal caches,
where appropriate. As an example and not by way of limitation,
processor 402 may include one or more instruction caches, one or
more data caches, and one or more translation lookaside buffers
(TLBs). Instructions in the instruction caches may be copies of
instructions in memory 404 or storage 406, and the instruction
caches may speed up retrieval of those instructions by processor
402. Data in the data caches may be copies of data in memory 404 or
storage 406 for instructions executing at processor 402 to operate
on; the results of previous instructions executed at processor 402
for access by subsequent instructions executing at processor 402 or
for writing to memory 404 or storage 406; or other suitable data.
The data caches may speed up read or write operations by processor
402. The TLBs may speed up virtual-address translation for
processor 402. In particular embodiments, processor 402 may include
one or more internal registers for data, instructions, or
addresses. The present disclosure contemplates processor 402
including any suitable number of any suitable internal registers,
where appropriate. Where appropriate, processor 402 may include one
or more arithmetic logic units (ALUs); be a multi-core processor;
or include one or more processors 402. Although this disclosure
describes and illustrates a particular processor, this disclosure
contemplates any suitable processor.
[0047] In particular embodiments, memory 404 includes main memory
for storing instructions for processor 402 to execute or data for
processor 402 to operate on. As an example and not by way of
limitation, computer system 400 may load instructions from storage
406 or another source (such as, for example, another computer
system 400) to memory 404. Processor 402 may then load the
instructions from memory 404 to an internal register or internal
cache. To execute the instructions, processor 402 may retrieve the
instructions from the internal register or internal cache and
decode them. During or after execution of the instructions,
processor 402 may write one or more results (which may be
intermediate or final results) to the internal register or internal
cache. Processor 402 may then write one or more of those results to
memory 404. In particular embodiments, processor 402 executes only
instructions in one or more internal registers or internal caches
or in memory 404 (as opposed to storage 406 or elsewhere) and
operates only on data in one or more internal registers or internal
caches or in memory 404 (as opposed to storage 406 or elsewhere).
One or more memory buses (which may each include an address bus and
a data bus) may couple processor 402 to memory 404. Bus 412 may
include one or more memory buses, as described below. In particular
embodiments, one or more memory management units (MMUs) reside
between processor 402 and memory 404 and facilitate accesses to
memory 404 requested by processor 402. In particular embodiments,
memory 404 includes random access memory (RAM). This RAM may be
volatile memory, where appropriate Where appropriate, this RAM may
be dynamic RAM (DRAM) or static RAM (SRAM). Moreover, where
appropriate, this RAM may be single-ported or multi-ported RAM. The
present disclosure contemplates any suitable RAM. Memory 404 may
include one or more memories 404, where appropriate. Although this
disclosure describes and illustrates particular memory, this
disclosure contemplates any suitable memory.
[0048] In particular embodiments, storage 406 includes mass storage
for data or instructions. As an example and not by way of
limitation, storage 406 may include an HDD, a floppy disk drive,
flash memory, an optical disc, a magneto-optical disc, magnetic
tape, or a Universal Serial Bus (USB) drive or a combination of two
or more of these. Storage 406 may include removable or
non-removable (or fixed) media, where appropriate. Storage 406 may
be internal or external to computer system 400, where appropriate.
In particular embodiments, storage 406 is non-volatile, solid-state
memory. In particular embodiments, storage 406 includes read-only
memory (ROM). Where appropriate, this ROM may be mask-programmed
ROM, programmable ROM (PROM), erasable PROM (EPROM), electrically
erasable PROM (EEPROM), electrically alterable ROM (EAROM), or
flash memory or a combination of two or more of these. This
disclosure contemplates mass storage 406 taking any suitable
physical form. Storage 406 may include one or more storage control
units facilitating communication between processor 402 and storage
406, where appropriate. Where appropriate, storage 406 may include
one or more storages 406. Although this disclosure describes and
illustrates particular storage, this disclosure contemplates any
suitable storage.
[0049] In particular embodiments, I/O interface 408 includes
hardware, software, or both providing one or more interfaces for
communication between computer system 400 and one or more I/O
devices. Computer system 400 may include one or more of these I/O
devices, where appropriate. One or more of these I/O devices may
enable communication between a person and computer system 400. As
an example and not by way of limitation, an I/O device may include
a keyboard, keypad, microphone, monitor, mouse, printer, scanner,
speaker, still camera, stylus, tablet, touch screen, trackball,
video camera, another suitable I/O device or a combination of two
or more of these. An I/O device may include one or more sensors.
This disclosure contemplates any suitable I/O devices and any
suitable I/O interfaces 408 for them. Where appropriate, I/O
interface 408 may include one or more device or software drivers
enabling processor 402 to drive one or more of these I/O devices.
I/O interface 408 may include one or more I/O interfaces 408, where
appropriate. Although this disclosure describes and illustrates a
particular I/O interface, this disclosure contemplates any suitable
I/O interface.
[0050] In particular embodiments, communication interface 410
includes hardware, software, or both providing one or more
interfaces for communication (such as, for example, packet-based
communication) between computer system 400 and one or more other
computer systems 400 or one or more networks. As an example and not
by way of limitation, communication interface 410 may include a
network interface controller (NIC) or network adapter for
communicating with an Ethernet or other wire-based network or a
wireless NIC (WNIC) or wireless adapter for communicating with a
wireless network, such as a WI-FI network. This disclosure
contemplates any suitable network and any suitable communication
interface 410 for it. As an example and not by way of limitation,
computer system 400 may communicate with an ad hoc network, a
personal area network (PAN), a local area network (LAN), a wide
area network (WAN), a metropolitan area network (MAN), or one or
more portions of the Internet or a combination of two or more of
these. One or more portions of one or more of these networks may be
wired or wireless. As an example, computer system 400 may
communicate with a wireless PAN (WPAN) (such as, for example, a
BLUETOOTH WPAN), a WI-FI network, a WI-MAX network, a cellular
telephone network (such as, for example, a Global System for Mobile
Communications (GSM) network), or other suitable wireless network
or a combination of two or more of these. Computer system 400 may
include any suitable communication interface 410 for any of these
networks, where appropriate. Communication interface 410 may
include one or more communication interfaces 410, where
appropriate. Although this disclosure describes and illustrates a
particular communication interface, this disclosure contemplates
any suitable communication interface.
[0051] In particular embodiments, bus 412 includes hardware,
software, or both coupling components of computer system 400 to
each other. As an example and not by way of limitation, bus 412 may
include an Accelerated Graphics Port (AGP) or other graphics bus,
an Enhanced Industry Standard Architecture (EISA) bus, a front-side
bus (FSB), a HYPERTRANSPORT (HT) interconnect, an Industry Standard
Architecture (ISA) bus, an INFINIBAND interconnect, a low-pin-count
(LPC) bus, a memory bus, a Micro Channel Architecture (MCA) bus, a
Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-X)
bus, a serial advanced technology attachment (SATA) bus, a Video
Electronics Standards Association local (VLB) bus, or another
suitable bus or a combination of two or more of these. Bus 412 may
include one or more buses 412, where appropriate. Although this
disclosure describes and illustrates a particular bus, this
disclosure contemplates any suitable bus or interconnect.
[0052] Herein, reference to a computer-readable storage medium
encompasses one or more non-transitory, tangible computer-readable
storage media possessing structure. As an example and not by way of
limitation, a computer-readable storage medium may include a
semiconductor-based or other integrated circuit (IC) (such, as for
example, a field-programmable gate array (FPGA) or an
application-specific IC (ASIC)), a hard disk, an HDD, a hybrid hard
drive (HHD), an optical disc, an optical disc drive (ODD), a
magneto-optical disc, a magneto-optical drive, a floppy disk, a
floppy disk drive (FDD), magnetic tape, a holographic storage
medium, a solid-state drive (SSD), a RAM-drive, a SECURE DIGITAL
card, a SECURE DIGITAL drive, or another suitable computer-readable
storage medium or a combination of two or more of these, where
appropriate. Herein, reference to a computer-readable storage
medium excludes any medium that is not eligible for patent
protection under 35 U.S.C. .sctn.101. Herein, reference to a
computer-readable storage medium excludes transitory forms of
signal transmission (such as a propagating electrical or
electromagnetic signal per se) to the extent that they are not
eligible for patent protection under 35 U.S.C. .sctn.101. A
computer-readable non-transitory storage medium may be volatile,
non-volatile, or a combination of volatile and non-volatile, where
appropriate.
[0053] This disclosure contemplates one or more computer-readable
storage media implementing any suitable storage. In particular
embodiments, a computer-readable storage medium implements one or
more portions of processor 402 (such as, for example, one or more
internal registers or caches), one or more portions of memory 404,
one or more portions of storage 406, or a combination of these,
where appropriate. In particular embodiments, a computer-readable
storage medium implements RAM or ROM. In particular embodiments, a
computer-readable storage medium implements volatile or persistent
memory. In particular embodiments, one or more computer-readable
storage media embody software. Herein, reference to software may
encompass one or more applications, bytecode, one or more computer
programs, one or more executables, one or more instructions, logic,
machine code, one or more scripts, or source code, and vice versa,
where appropriate. In particular embodiments, software includes one
or more application programming interfaces (APIs). This disclosure
contemplates any suitable software written or otherwise expressed
in any suitable programming language or combination of programming
languages. In particular embodiments, software is expressed as
source code or object code. In particular embodiments, software is
expressed in a higher-level programming language, such as, for
example, C, Perl, or a suitable extension thereof. In particular
embodiments, software is expressed in a lower-level programming
language, such as assembly language (or machine code). In
particular embodiments, software is expressed in JAVA. In
particular embodiments, software is expressed in Hyper Text Markup
Language (HTML), Extensible Markup Language (XML), or other
suitable markup language.
[0054] The present disclosure encompasses all changes,
substitutions, variations, alterations, and modifications to the
example embodiments herein that a person having ordinary skill in
the art would comprehend. Similarly, where appropriate, the
appended claims encompass all changes, substitutions, variations,
alterations, and modifications to the example embodiments herein
that a person having ordinary skill in the art would
comprehend.
* * * * *
References