HK1163286B - Search extensibility to third party applications - Google Patents

Description

Search expansion capability to third party applications

RELATED APPLICATIONS

This application claims the benefit of U.S. provisional patent application No.61/321,764, filed on 7/4/2010, the entire contents of which are incorporated herein by reference.

The invention disclosed and claimed in this application was prematurely disclosed without Apple authorization when a prototype of Apple's iPhone4, 3/25/2010, was obviously stolen from the Apple engineer. The U.S. priority application on which this application is based has not been filed prior to this apparent theft event.

Technical Field

The present disclosure relates to extending search capabilities to third party applications on computing devices.

Background

Currently, many applications have been developed to run on multifunction devices, such as cellular phones, Personal Digital Assistants (PDAs), etc., including media players. Many of these applications are provided by sources other than the vendor of the multifunction device, and therefore they are often referred to as third party applications. These applications may perform various functions, such as providing entertainment, social networking, and the like. In performing these functions, the multifunction devices can access content stored in the multifunction devices or network-based (e.g., internet) content.

In order to enable a user of a multifunction device to organize and manage the multifunction device more simply and conveniently, an operating system installed on the multifunction device generally provides a search capability. Because many applications installed on multifunction devices are third-party applications, conventional operating systems installed on multifunction devices do not extend their search capabilities to these third-party applications.

Disclosure of Invention

Some embodiments include one or more Application Program Interfaces (APIs) in the environment through which calling program code interacting with other program code is called. Via an API between the caller and the called code, various function calls, messages or other types of calls may be sent, which may also include various parameters. In addition, the API may provide the calling program code with the following capabilities: data types or classes defined in the API and implemented in the called program code can be used.

At least some embodiments include an environment for interaction by a calling software component with a called software component through an API. Methods for operating in such an environment through an API include sending one or more function calls, messages, other types of calls, or parameters through the API.

At least some embodiments of the invention include one or more APIs in the environment, with search capabilities extended to one or more third party applications on the multifunction device. Various function calls or messages are sent via APIs between the operating system of the multifunction device and the third party application. The exemplary API sends function calls to enable indexing and searching of content associated with third party applications.

Certain embodiments of the present disclosure include methods for extending search capabilities to third party applications installed on a multifunction device. In one embodiment, the record associated with the third party application is indexed in the following process: this process is separate from other third party applications, system applications, and search packages installed on the multifunction device using a search plug-in specific to the third party application. Note that the indexing may be performed without invoking a third party application. Additionally, indexed records may be searched in response to a user's search query without invoking (such as launching or running) a third party application.

According to some embodiments of the present disclosure, a third party application installed on a multifunction device may provide a search plug-in specific to the third party application. The search plug-in may be initiated to transfer records associated with the third party application to a search daemon on the multifunction device that runs in a separate process. An Identifier (ID) of a record may specify how the characteristics of the record should be when displayed in search results generated in response to a user search query. Each ID may further include a local ID having sub-IDs corresponding to different types of content within the document associated with the respective record.

Various means for performing one or more of the above-mentioned methods are also described, as well as machine-readable media which, when executed by a processing system, cause the processing system to perform these methods.

Other methods, apparatus, and machine-readable media are also described.

Drawings

The invention will be described with reference to the accompanying drawings, in which:

FIG. 1 illustrates a block diagram of an exemplary API architecture that may be used in certain embodiments of the present invention;

FIG. 2 is an exemplary embodiment of a software stack that may be used with certain embodiments of the present invention;

FIG. 3 is a diagram of interactions between a search daemon and a third party application running on a multifunction device, according to one embodiment of the invention;

FIG. 4 is a flow diagram of one embodiment of a method on a multifunction device to establish search and indexing capabilities for third party applications;

FIG. 5 is a flow diagram of one embodiment of a method on a multifunction device for processing changes in application data by a third party application;

FIG. 6 is a flow diagram of one embodiment of a method on a multifunction device for processing data changes in an application associated with a third party application by a search daemon;

FIG. 7 is a flow diagram of one embodiment of a method on a multifunction device for indexing application data by a search daemon;

FIG. 8 is a flow diagram of one embodiment of a method on a multifunction device for indexing application data by an application indexer;

FIG. 9 is a flow diagram of one embodiment of a method for a search daemon to search indexed application data associated with a third party application;

FIG. 10 is one embodiment of a search database on a multifunction device;

FIG. 11 is one embodiment of a local identifier for an exemplary document;

FIG. 12 is a perspective view of an apparatus according to one embodiment of the present invention;

FIG. 13 shows an embodiment of a wireless device including wireless communication capabilities;

fig. 14 shows another example of an apparatus according to an embodiment of the invention.

Detailed Description

Various embodiments and aspects of the disclosure will be described with reference to the following detailed discussion, and the accompanying drawings will illustrate the various embodiments. The following description and drawings are illustrative of the invention and are not to be construed as limiting the disclosure. Numerous specific details are described to provide a thorough understanding of various embodiments of the invention. However, in certain instances, well-known or conventional details are not described in order to provide a concise discussion of embodiments of the present inventions.

Some portions of the detailed descriptions which follow are presented in terms of algorithms including operations on data stored in a computer memory. An algorithm is, in general, a self-consistent sequence of operations leading to a desired result. The operations generally require or involve physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has been found that it is sometimes convenient to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like, primarily for reasons of common usage.

It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical parameters and are merely convenient labels applied to these parameters. Unless specifically stated otherwise as apparent from the following discussions, it is appreciated that throughout the present specification discussions utilizing terms such as "processing," "computing," "calculating," "determining," "displaying," or the like, may refer to the action and processes of a data processing system, or similar electronic device, that manipulates and transforms data represented as physical (electronic) quantities within the system's registers and memories into other data similarly represented as physical quantities within the system's memories or registers or other such information storage, transmission or display devices.

The present invention is directed to an apparatus for performing one or more of the operations described herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a machine (e.g., computer) readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, magnetic-optical disks, read-only memories (ROMs), Random Access Memories (RAMs), erasable programmable ROMs (eproms), electrically erasable programmable ROMs (eeproms), flash memory, magnetic or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a bus.

A machine-readable medium includes any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computer). For example, the machine stores and transmits (internally or to other devices over a network) code and data using a machine-readable medium (e.g., a machine-readable storage medium such as a magnetic disk, an optical disk, a random access memory, a read only memory, a flash memory device, a phase change memory) and a machine-readable communication medium (e.g., an electrical, optical, acoustical or other form of propagated signal — e.g., carrier waves, infrared signals, digital signals, etc.).

At least some embodiments of the present disclosure include one or more application program interfaces in an environment having search software that interacts with a software application. Various function calls or messages are sent via the application program interface between the search software and the software application. Sending a function call or message may include publishing, initiating, invoking, or receiving a function call or message. The example application program interface sends function calls to implement various operations (e.g., search, networking, service discovery, etc.) for a device having a display area. An API may implement a function with parameters, variables, or pointers. The API may receive parameters in the form of disclosed parameter combinations or other parameter combinations. In addition to the disclosed APIs, other APIs may perform similar functions to the disclosed APIs, either alone or in combination.

The display area may be presented in the form of a window. A window is a display area that may or may not have edges and may be the entire display area or a portion of the display. In some embodiments, the display area may have at least one window and/or at least one view (e.g., web page, text, or image content). The disclosed methods, systems, and devices may be implemented via display areas, windows, and/or views.

At least certain embodiments of the present disclosure may be part of a portable electronic device, such as a digital media player (e.g., a portable music and/or video media player), which may include a media processing system for presenting media, a storage device for storing media, and may further include a Radio Frequency (RF) transceiver (e.g., an RF transceiver for a cellular telephone) coupled with an antenna system and the media processing system. In some embodiments, data stored on a remote storage device may be transmitted to the portable electronic device via the RF transceiver. The data may be, for example, one or more of music or other audio, still pictures or animation, etc.

The portable media player may include a media selection device, such as that of Applecomputer, Inc. of Cupertino, CAOr iPodA click wheel (click wheel) device, a touch screen input device, a button device, a movable pointing device, or other input device on the media player. The media selection device may be used to select media stored on the storage device and/or the remote storage device. In at least some embodiments, the portable media player may include a display device coupled to the media processing system to display titles or other indicators of media selected through the input device and presented through a speaker or headphone(s), or on the display device, or on both the display device and the speaker or headphone(s). In some embodiments, the display device and the input device are integrated, while in other embodiments, the display device and the input device are separate devices.

Embodiments of the invention described herein may be part of other types of data processing systems, such as entertainment systems or Personal Digital Assistants (PDAs), or general purpose computer systems, or special purpose computer systems, or embedded devices in another device, or cellular telephones or multi-function touch tablets that do not include a media player, or other multi-function touch devices, or devices that combine aspects or functions of these devices (e.g., a media player such as a media playerPortable media player) is combined with a PDA, entertainment system and cellular telephone in one device,). Because these devices typically have multiple functions, these devices may also be referred to hereinafter as multi-function devices. In the present disclosure, the electronic device and the consumer device are device types.

In some embodiments, the platform provides various search, service discovery, and networking operations. The platform includes hardware components and an operating system. The hardware component may include a processing unit coupled to the input panel and a memory coupled to the processor. The operating system includes one or more programs stored in the memory and configured to be executed by the processing unit. The one or more programs include various instructions for communicating function calls or messages through an Application Program Interface (API) to perform various search, service discovery, and networking operations.

One or more APIs may be used in some embodiments. An API is an interface implemented by a program code component or a hardware component (hereinafter "API-implementing component"), allowing different program code components or hardware components (hereinafter "API-calling components") to access and use one or more functions, methods, procedures, data structures, classes, and/or other services provided by the API-implementing component. The API may define one or more parameters that are communicated between the API-calling component and the API-implementing component.

The API allows a developer of the API-calling component (which may be a developer of a third party application) to enhance (legacy) the specialized features provided by the API-implementing component. There may be one API-calling component or there may be more than one such component. An API may be a source code interface provided by a computer system or library to support service requests from applications. An Operating System (OS) may have multiple APIs to allow applications running on the OS to call one or more of these APIs, and a service (e.g., a library) may have multiple APIs to allow applications using these services to call one or more of these APIs. The API may be specified in terms of a programming language that is interpreted or compiled when the application is built.

In some embodiments, the API-implementing component may provide more than one API, each of which provides a different view of or has different aspects to access different aspects of the functionality implemented by the API-implementing component. For example, one API of the API-implementing component may provide a first set of functions and may be exposed to third-party developers, and another API of the API-implementing component may be hidden (not exposed) and provide a subset of the first set of functions and another set of functions, such as testing or debugging functions beyond the first set of functions. In other embodiments, the API-implementing component may itself invoke one or more other components through the underlying API, and thus be both an API-calling component and an API-implementing component.

The API defines the language and parameters used by the API-calling component in accessing and using the application-specific properties of the API-implementing component. For example, the API-calling component accesses the specified properties of the API-implementing component through one or more API calls (e.g., implemented through calls to functions or methods) exposed by the API, and passes data and control information using parameters via the API calls. The API-implementing component may return a value through the API in response to an API call from the API-calling component. While an API defines the syntax and results of an API call (e.g., how the API call is called and what the API call does), an API does not reflect how the API call completes the function specified by the API call. Various API calls are sent via one or more application program interfaces between the call (API calling component) and the API implementing component. Sending an API call may include issuing, initiating, calling, receiving, returning, or responding to a function call or message; in other words, the sending may describe actions by the API-calling component or by the API-implementing component. A function call or other call to the API may send or receive one or more parameters through a parameter list or other structure. A parameter may be a constant, key, data structure, object class, variable, data type, pointer, array, list, or pointer to a function or method, or other way of referencing data or other items that can be passed through the API.

Moreover, the data types or classes can be provided by the API and implemented by the API-implementing component. Thus, the API-calling component may declare variables, use pointers, use or instantiate constant values for these types or classes by using definitions provided in the API (instantiation).

In general, an API may be used to access services or data provided by an API-implementing component or to initiate performance of operations or computations provided by the API-implementing component. For example, the API-implementing component and the API-calling component may each be any of an operating system, a library, a device driver, an API, an application program, or other module (it being understood that the API-implementing component and the API-calling component may be the same or different types of modules as each other). In some cases, the API-implementing component may be implemented at least in part by firmware, microcode, or other hardware logic. In some embodiments, the API may allow the client program to use services provided by a Software Development Kit (SDK) library. In other embodiments, an application or other client may use an API provided by an application basic framework (application framework). In these embodiments, the application or client may combine calls to functions or methods provided by the SDK and provided by the API, or use data types or objects defined in the SDK and provided by the API. In these embodiments, the application base framework may provide a main event loop for the program in response to various events defined by the framework. The API allows events and response events to be specified by the application using the application base framework. In some embodiments, API calls may report to an application the capabilities or state of a hardware device, including capabilities or states related to aspects such as input capabilities and states, output capabilities and states, processing capabilities, power states, storage capacity and states, communication capabilities, and the like, and may be implemented in part through firmware, microcode, or other low-level logic executing in part on hardware components.

The API-calling component may be a local component (i.e., on the same data processing system as the API-implementing component) or a remote component (i.e., on a different data processing system than the API-implementing component) that communicates with the API-implementing component through a network-based API. It should be appreciated that an API-implementing component may also act as an API-calling component (i.e., it may make API calls to APIs exposed by other API-implementing components), and by implementing an API that is exposed to another API-calling component, an API-calling component may also act as an API-implementing component.

An API may allow multiple API-calling components written using different programming languages to communicate with an API-implementing component (thus an API may include features for translating calls and returns between the API-implementing component and the API-calling component); however, the API may be implemented by a special programming language. In one embodiment, the API-calling component is capable of calling APIs from different vendors, such as one set of APIs from an OS vendor, another set of APIs from a plug-in vendor, and another set of APIs from another vendor (e.g., a vendor of a software library) or a creator of the other set of APIs.

FIG. 1 shows a block diagram of an exemplary API architecture that may be used in some embodiments of the present invention. As shown in FIG. 1, the API architecture 100 includes an API-implementing component 110 (e.g., an operating system, library, device driver, API, application, software, or other module) that implements an API 120. The API120 specifies one or more functions, methods, classes, objects, protocols, data structures, formats, and/or other characteristics of the API-implementing component that may be used by the API-calling component 130. The API120 can specify at least one calling convention (convention) that specifies how a function in the API-implementing component receives parameters from the API-calling component and how the function returns results to the API-calling component. An API calling component 130 (e.g., an operating system, library, device driver, API, application, software, or other module) makes API calls through the API120 to access and use the API-implementing component 110 properties specified by the API 120. The API implementing component 110 can return a value to the API calling component 130 through the API120 in response to the API call.

It is to be appreciated that the API-implementing component 110 can include additional functions, methods, classes, data structures, and/or other characteristics not specified by the API120 and not available to the API-calling component 130. It should be appreciated that the API-calling component 130 can be on the same system as the API-implementing component 110, or can be located remotely and access the API-implementing component 110 over a network using the API 120. Although FIG. 1 shows a single API-calling component 130 interacting with the API120, it should be appreciated that the API120 may be used with other API-calling components written in a different language (or the same language) as the API-calling component 130.

The API-implementing component 110, the API120, and the API-calling component 130 may be stored in a machine-readable medium, which includes any means for storing information in a form readable by a machine (e.g., a computer or other data processing system). For example, a machine-readable medium includes magnetic disks, optical disks, random access memories, read only memories, flash memory devices, and the like.

In an exemplary embodiment of FIG. 2 ("software stack"), an application may use several service APIs to call services 1 or 2 and several Operating System (OS) APIs to call the OS. Services A and B may use several OSAPIs to invoke the OS.

Note that service 2 has two APIs, one (service 2API1) that receives calls from application 1 and returns values to application 1, and the other (service 2API2) that receives calls from application 2 and returns values to application 2. Service 1 (which may be a software library, for example) calls the OSAPI1 and receives return values from the OSAPI1, service 2 (which may be a software library, for example) calls the OSAPI1 and the OSAPI2 and receives return values from the OSAPI1 and the OSAPI 2. Application 2 calls the OSAPI2 and receives return values from OSAPI 2.

Fig. 3 is a diagram of interactions between a search daemon (searchdaemon)320 running on a multifunction device and third party applications 310, according to one embodiment of the invention. Third party applications, as used in this application, generally refer to software applications provided by entities other than the manufacturer of the multifunction device. Typically, a user of a multifunction device may install one or more third-party applications executable on the multifunction device to perform a particular set of tasks or functions. Some examples of third-party applications include e-book readers, social network managers, and the like.

In general, the multifunction device may store application data associated with third party applications 310 referenced (index) by search daemon 320 in search database 380 on the multifunction device. In one embodiment, an apparatus may have a plurality of third party applications (e.g., applications 310), each of which operates in the manner described herein, and has a search daemon 320 or an instance (instance) of the search daemon 320 that was created for the respective third party application using that instance. In some embodiments, search daemon 320 may launch (launch) application indexer (indexer)330 to index application data. In particular, the application indexer 330 may initiate an instance of an application search package (bundle)340 provided by the third party application 310 to retrieve (retrieve) a record of the application data for indexing. Note that for security reasons, the application search package 340 is initiated in a separate process from other third party applications, system applications, and search packages. Also, the separate process in which the application search package 340 is initiated and the third party application 310 associated with the application search package 340 may have the same privileges (privilege) (e.g., privileges to read and write to selected portions of memory space, but otherwise restricted to read and write to other portions of memory). Thus, the application search package 340 is given permission to access the content that the third party application 310 is allowed to access, and is prohibited from accessing the content that the third party application 310 is not allowed to access. In some embodiments, some portions of the search daemon 320 (e.g., the application director 330) may be given the same privileges (e.g., memory space limitations) as the third party application 310. In some embodiments, in response to a user request, search daemon 320 may search database 380 for indexed application data without launching third party application 310. Details of some embodiments of interacting between search daemon 320 and third party application 310 to index and search application data are discussed below to further clarify the above concepts.

In one embodiment, third party application 310 is launched to run on a multifunction device. When running, the third party application 310 causes the application data 315 to change. For example, the third party application 310 may modify existing records stored on the multifunction device, download new records onto the multifunction device, and/or remove (or delete) existing records stored on the multifunction device. When a third party application 310 changes the application data 315, the third party application 310 also sends an Identifier (ID) of the record in the application data 315 that has changed to the search daemon 320. Search daemon 320 may temporarily store the IDs of the changed records in update list 325.

Thereafter, when search daemon 320 needs to build the indexed data, search daemon 320 may initiate a separate process to run application indexer 330. Search daemon 320 may establish indexed data periodically, or when a search is requested, or at other times or intervals. Alternatively, the search daemon 320 may build the indexed data when the search daemon 320 finds new information in the update list 325. This may occur when the third party application 310 notifies the search daemon 320 of the update identifier. There may also be triggers external to application 310 that may cause indexing to begin, such as application updates, system recovery, system updates, and the like. The application indexer 330 may load the application search package 340. In some embodiments, the application search package 340 is a search-related plug-in specific to the third party application 310. The third party application 310 may have provided the application search package 340 when the third party application 310 is installed on the multifunction device. The application indexer 330 may provide the IDs of the changed records from the update list 325 to the application search package 340. In response, application search package 340 provides the changed records to application indexer 330 to be indexed. Alternatively, the application indexer 330 may request all records associated with the third party application 310 from the application search package 340. In a certain embodiment, the instance of the application director 330 for the third party application 310 runs in its own process and has the same privileges as the third party application 310 (corresponding to memory control, memory space, memory allocation, file system control, and network control).

In some embodiments, if matching a user search query, each record includes a set of attributes describing how the corresponding record should be displayed in the search results. For example, an exemplary record may include an ID, a content title, a content subtitle, and an ID specific to an application (also referred to as a local ID). When a record matches a user search query, the title and subtitles of the record may be presented in search results of the user search query.

Using the records from the application search package 340, the application indexer 330 may build or add the records in a search database 380, which may include metadata for the content associated with the records. In certain embodiments, the search database 380 includes multiple databases that are synchronized with one another. For example, the search database 380 may include a first database to store indexed content and a second database to store records of indexed content. More details of one embodiment of searching the database are discussed below.

When a user submits a user search query, search daemon 320 may access search database 380 for records that match the user search query. Note that the search daemon 320 may search for records associated with application data of the third party application 310 without launching the third party application 310. Search daemon 320 may present portions of records that match the user search query, e.g., display titles and subtitles of matching records in a search results area within a window. In some embodiments, the user may select a record from the matching records. In response to the user's selection, search daemon 320 may launch third party application 310 on the multifunction device to present content associated with the selected record. For example, the content may include video data, and the third party application 310 may be launched to play the video; alternatively, the content may include an e-book, and the third-party application 310 may be launched to display the e-book.

FIG. 4 is a flow diagram of one embodiment of a method for establishing search and indexing capabilities for third party applications on a multifunction device. The method may be performed by hardware, software, firmware, or any combination thereof.

In some embodiments, installation of the third party application is initiated on the multifunction device, block 410. At block 420, an application search package specific to the third party application is stored at a predetermined location of the third party application of the multifunction device. Broadly speaking, an application search package is a plug-in provided by a third party application. The application search package may be loaded to transmit a record of content associated with the third party application. At block 430, the metadata of the third party application is examined to determine whether the third party application wants to index content associated with the third party application. At block 445, the third party application is registered if the third party application wants to index the content. For example, as described below, a search daemon running on the multifunction device may keep track of a list of registered applications at a central location, and the search daemon may index content associated with third party applications.

FIG. 5 is a flow diagram of an embodiment of a method of processing a change in application data by a third party application on a multifunction device. The method may be performed by hardware, software, firmware, or any combination thereof.

In some embodiments, a third party application is run on the multifunction device, block 510. At block 520, the third party application changes a record of application data associated with the third party application. At block 530, the third party application sends the Identifier (ID) of the changed record to a search daemon running on the multifunction device.

FIG. 6 is a flow diagram of an embodiment of a method of processing changes in application data associated with a third party application by a search daemon on a multifunction device. The method may be performed by hardware, software, firmware, or any combination thereof.

At block 610, the search daemon running on the multifunction device receives the ID of the changed record of application data associated with the third party application. At block 620, the search daemon places the received ID in an update list. As described below, the search daemon may thereafter use the updated list to determine if it needs to index a record.

FIG. 7 is a flow diagram of one embodiment of a method for indexing application data by a search daemon on a multifunction device. The method may be performed by hardware, software, firmware, or any combination thereof.

At block 710, the search daemon examines the update list to determine if any records have changed. In some embodiments, the search daemon may periodically check the updated list. If there is a record change, the search daemon will need to index the changed record. At block 720, the search daemon may initiate an application indexer in a separate process to index the changed records.

FIG. 8 is a flow diagram of one embodiment of a method for indexing application data by an application indexer at a multifunction device. The method may be performed by hardware, software, firmware, or any combination thereof.

At block 810, an application indexer running on the multifunction device instantiates an instance of the application search package in a separate process from other third party applications, system applications, and search packages. The application search package is a plug-in specific to a third party application installed on the multifunction device. At block 820, the application indexer passes the ID of the changed record to the application search package to request the changed record from the application search package. Alternatively, the application indexer may decide to index all records associated with the third party application and thereby request all records associated with the third party application from the application search package.

At block 830, the application indexer receives the requested record from the application search package. Each record may contain a set of attributes of the content associated with the record, such as a title of the content, a subtitle of the content, and a local identifier of the content used by the third-party application. At block 840, the received records are indexed using an indexer and the indexed records are stored in a search database of the multifunction device.

FIG. 9 is a flow diagram of one embodiment of a method for searching indexed application data associated with third party applications by a search daemon. The method may be performed by hardware, software, firmware, or any combination thereof.

At block 910, the search daemon receives a user search query. For example, a user may submit a user search query to find records whose titles have a particular text string (e.g., "spring"). At block 920, the search daemon searches a search database containing indexed records for records matching the user search query.

At block 930, the search daemon returns an identifier for each record that matches the user search query in the search results to be presented to the user. In some embodiments, the identifier includes a title, a subtitle, a reference to an associated third-party application, a local identifier (specific to the third-party application), and a category.

In some embodiments, the owner of the search box into which the user search query is entered receives search results from the search daemon at the time of the query. The user may select a record from the search results. The host may be a search application or a third party application. If the host is a search application that performs a global search, the search application may launch a third party application and communicate in a local identifier and category from a search daemon. If the host is a third party application, it may simply present the content associated with the selected record. Note that when the host is a third-party application, only records related to the third-party application in the search result may be displayed.

FIG. 10 illustrates one embodiment of a search database 1000 on a multifunction device. The search database 1000 includes a first database 1010 and a second database 1020. In other embodiments, the search database 1000 may include more than two databases.

In some embodiments, the first database stores content (e.g., documents, web pages, e-books, videos, etc.) and their respective IDs associated with certain third-party applications. The second database 1020 may store records of content. In the present example, each record includes an ID of the content, a title of the content, a subtitle of the content, and a local ID of the content. The local ID is used by third party applications when accessing and processing content. Thus, the local ID may also be referred to as an application ID. Details of one embodiment of the local ID are shown in fig. 11. The content in the search database 1000 is organized by referencing records. A search daemon running on the multifunction device may index records and search the search database 1000 in response to a user search query as described above.

In some embodiments, search database 1000 stores content of all categories (e.g., music, videos, e-books, podcasts (podcasts), etc.) on a multifunction device. Although the search performed in the search database 1000 may be fast, the search database 1000 may become too large to be backed up. Thus, the search database 1000 has to be rebuilt from scratch if necessary.

Alternatively, there is one search database for each category of content on the multifunction device. For example, a first search database may be established for music, a second search database may be established for podcasts, a third search database may be established for electronic books, a fourth search database for a first third party application, a fifth search database for a second third party application, and so on. By partitioning different kinds of content into different search databases, the search databases may be backed up at different frequencies depending on the stability of the content in each search database. The more stable the content, the less frequently the corresponding search database needs to be backed up. However, searching for content in a search database can be slow due to the multiple search databases. To mitigate the impact on performance, a cache may be implemented on the multifunction device to store a record of frequently accessed content. In this way, the search may become faster.

FIG. 11 shows one embodiment of an exemplary file ID. ID1100 includes a title 1110 of the exemplary document, a subtitle 1120 of the exemplary document, a third party application 1130 associated with the exemplary document, a category identifier 1140 of the exemplary document, and an application specific ID1150 of the exemplary document.

In some embodiments, the ID1100 is unique only to a particular category in the third party application. The category is a type of content, e.g., slide, video, document, podcast, etc. Thus, the application specific ID1150 is unique for each category, and each category is unique in third party applications.

In some embodiments, the third party application may be associated with multiple categories of content. For example, the third party application may be associated with a file in which the video and podcast are embedded. Third party applications may place such files (e.g., documents) under a single category, as long as the search daemon is concerned. If a third party application wishes to be able to return results at a finer granularity (e.g., just returning the podcast portion of the file), it can provide an ID that points directly to the podcast and index it within the podcast category. The third party application may choose to submit either or both for indexing. The search daemon may not distinguish between the results in the subdivided case and the unified results.

In certain embodiments, the methods, systems, and apparatus of the present disclosure may be performed in a variety of devices including electronic devices, consumer devices, data processing devices, desktop computers, laptop computers, wireless devices, cellular devices, tablet devices, handheld devices, multi-touch data processing devices, any combination of these devices, or other similar devices. Some examples of such devices are shown in fig. 12-14.

FIG. 12 shows an apparatus 2950 according to an embodiment of the disclosure. The device 2950 may include a housing 2952, a display/input device 2954, a speaker 2956, a microphone 2958 and an optional antenna 2960 (which may be visible on the exterior of the housing or hidden within the housing). The device 2950 may also include a proximity sensor 2962 and an accelerometer 2964. The device 2950 may be a cellular telephone, or a device that integrates a PDA and a cellular telephone, or a device that integrates a media player and a cellular telephone, or a device that is both an entertainment system (e.g., for playing games) and a cellular telephone, or the device 2950 may be other types of devices described herein. In one particular embodiment, the device 2950 may comprise a cellular telephone, a media player, and a PDA, all of which are housed within the housing 2952. The device 2950 may have a form factor of: it is small enough to rest in the palm of an adult and light enough to be picked up by an adult with one hand. It will be understood that the term "portable" means that the device can be easily held in one or both hands of an adult user, such as a laptop computer, a laptop computer,Andare all portable devices.

In certain embodiments of the present disclosure, the apparatus 2950 may be used to implement at least some of the methods discussed in the present disclosure.

Fig. 13 shows an embodiment of a wireless device that includes the capability to conduct wireless communications. The wireless device 3100 may include an antenna system 3101. The wireless device 3100 may also include a digital and/or analog Radio Frequency (RF) transceiver 3102 that is coupled to the antenna system 3101 to transmit and/or receive voice, digital data, and/or media signals through the antenna system 3101.

The wireless device 3100 may also include a digital processing system 3103 to control the digital RF transceiver and manage voice, digital data, and/or media signals. Digital processing system 3103 may be a general purpose processing device such as a microprocessor or controller. Digital processing system 3103 may also be a special purpose processing device such as, for example, an ASIC (application specific integrated circuit), an FPGA (field programmable gate array), or a DSP (digital signal processor). Digital processing system 3103 may also include other devices known in the art to interface with the other components of wireless device 3100. For example, digital processing system 3103 may include analog-to-digital and digital-to-analog converters to interface with other components of wireless device 3100. Digital processing system 3103 may include a media processing system 3109, which may also include general or special purpose processing devices to manage media, such as files of audio data.

The wireless device 3100 may also include a storage device 3104 coupled to the digital processing system to store data and/or operating programs for the wireless device 3100. The storage device 3104 may also be, for example, any type of solid state or magnetic storage device. Storage 3104 may be or include a machine-readable medium.

Wireless device 3100 may also include one or more input devices 3105 coupled to digital processing system 3103 to accept user input (e.g., telephone numbers, names, addresses, media selections, etc.). The input device 3105 may also be, for example, one or more of a keyboard, a touchpad, a touch screen, a pointing device in combination with a display device, or the like.

The wireless device 3100 may also include at least one display device 3106 coupled to the digital processing system 3103 to display information (e.g., messages, phone call information, contact information, pictures, movies, and/or titles), or other indicators of media selected through the input device 3105. The display device 3106 may be, for example, an LCD display device. In one embodiment, the display device 3106 and the input device 3105 may be integrated in the same device (e.g., a touch screen LCD, such as a multi-touch input panel integrated with a display device (e.g., an LCD display device)). Display device 3106 may include a backlight 3106A to illuminate display device 3106 in some cases. It is understood that the wireless device 3100 may include multiple displays.

Wireless device 3100 may also include a battery 3107 to provide operating power to system components, including a digital RF transceiver 3102, a digital processing system 3103, a storage device 3104, an input device 3105, a microphone 3105A, an audio transducer 3108, a media processing system 3109, sensor(s) 3110, and a display device 3106. For example, battery 3107 may be a rechargeable or non-rechargeable lithium or nickel metal hydride battery. The wireless device 3100 may also include an audio transducer 3108, which may include one or more speakers and at least one microphone 3105A. In certain embodiments of the present invention, the wireless device 3100 may be used to implement at least part of the methods discussed in this disclosure.

Fig. 14 shows another example of an apparatus according to an embodiment of the invention. The device 3200 may include a processor, such as a microprocessor 3202, and a memory 3204 coupled to one another via a bus 3206. The device 3200 may optionally include a cache 3208 coupled to the microprocessor 3202. The device may optionally include a storage device 3240, which may be, for example, any type of solid state or magnetic storage device. Storage 3240 may be or include a machine-readable medium.

The device may also optionally include a display controller and display device 3210 coupled to the other components by the bus 3206. One or more input/output controllers 3212 may also be coupled to the bus 3206 to provide an interface to the input/output devices 3214 and to provide an interface to one or more sensors 3216 used to sense user activity. The bus 3206 may include one or more buses connected to each other through various bridges, controllers, and/or adapters as is well known in the art. The input/output device 3214 may include a keypad (keypad), a keyboard, or a cursor control device such as a touch input board. Also, the input/output devices 3214 may also include a network interface, which may be for a wired network or for a wireless network (such as an RF transceiver). The sensor 3216 may be any of the sensors described herein, including, for example, a proximity sensor or an ambient light sensor. In at least some implementations of the device 3200, the microprocessor 3202 may receive data from one or more sensors 3216 and may perform an analysis of such data in the manner described herein.

In certain embodiments of the present invention, the apparatus 3200 may be used to implement at least some of the methods discussed in the present invention.

In the foregoing specification, the invention has been described with reference to specific exemplary embodiments thereof. It will be evident that various modifications may be made thereto without departing from the broader spirit and scope of the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.

Claims (11)

1. A method for extending search capabilities to third party applications, comprising:

indexing records associated with third party applications installed on a device that uses a search plug-in specific to the third party applications to access records in an application data store associated with the third party applications, wherein a process for indexing the records indexes records received from the search plug-in by communicating an identification for the records to the search plug-in, wherein the search plug-in retrieves the identified records from the application data store without launching third party applications, wherein the process for indexing the records is isolated from other third party applications installed on the device; and

content is searched using the indexed records in response to a user search query.

2. The method of claim 1, further comprising:

presenting, via a graphical user interface, records matching the user search query; and

allowing a user to select records from records matching the user search query via the graphical user interface, and wherein the search plug-in is restricted to the same memory privileges as the third party application.

3. The method of claim 2, further comprising:

in response to the user selecting the record, initiating the third party application to present the record.

4. The method of claim 2, wherein presenting records matching the user search query comprises: displaying a set of attributes of the record on the graphical user interface, wherein the set of attributes is specified by a search plug-in specific to the third party application.

5. A method for extending search capabilities to third party applications, comprising:

installing a third party application on the computing device;

checking metadata of the third-party application to determine whether the third-party application wants to index content associated with the third-party application;

registering the third-party application if the third-party application wants to index content associated with the third-party application; and

invoking, by a search daemon specific to the third-party application and running on a computing device, a search plug-in specific to the third-party application in a separate process running with the same privileges as the third-party application to access records in an application data store associated with the third-party application, the search daemon requesting records associated with the third-party application from the search plug-in by communicating an identification for the records to the search plug-in, and receiving identified records from the search plug-in response to the search plug-in receiving an identifier, wherein the search plug-in retrieves the identified records from the application data store without launching a third-party application.

6. The method of claim 5, further comprising:

initiating the third party application in response to a user request, wherein the third party application changes records and sends the identification of the changed records to the search daemon to be stored in an update list that is usable by the search daemon to index the changed records.

7. The method of claim 6, wherein the search plug-in is invoked after the third party application is terminated.

8. The method of claim 6, further comprising:

providing the separate process with the same privileges as those granted to the third-party application.

9. A method for extending search capabilities to third party applications, comprising:

specifying, by a third party application executable on the data processing apparatus, a set of attributes of the following records: the record is presented when the record becomes part of search results of a search performed by a search daemon dedicated to the third party application in response to a user search query; and

providing, by the third-party application, an application search package specific to the third-party application, instantiating, by the search daemon running with the same privileges as the third-party application, an instance of the application search package to access a record in an application data store associated with the third-party application, wherein a search indexer instantiated by the search daemon to index the record requests the record from the application search package by communicating an identifier for the record to the application search package and receives the record from the application search package, the application search package communicating the record in response to receiving the identifier, and wherein the application search package retrieves the record from the application data store without launching the third-party application.

10. The method of claim 9, further comprising:

the third-party application changing a record of content associated with the third-party application;

the identifiers of those records that are changed are stored in a list accessible by the search indexer.

11. The method of claim 10, wherein the search indexer retrieves the identifier from the list after the third party application has terminated and uses the identifier to obtain changed records from the application search package.