Patent Application
20120151341
1. Field of the Invention
This invention relates generally to the field of computer systems. More particularly, the invention relates to an interactive screen saver method and apparatus.
2. Description of the Related Art
A screen saver is a well known type of computer program which typically generates graphical images on a computer's display after a specified period of inactivity. Historically, screen savers were designed to prevent phosphor burn-in on CRT and plasma computer monitors by blanking the screen or filling it with moving images when the computer is not in use. Because modern CRTs and liquid crystal display (LCD) computer monitors are much less susceptible to burn-in, screensavers today are primarily decorative or for entertainment, and usually feature moving images or patterns and sometimes sound effects.
An apparatus and computer-implemented method are described for an interactive screen saver. For example, a method according to one embodiment of the invention comprises: initiating a screen saver on a data processing device; detecting keyboard input and/or mouse input on the data processing device while the screen saver is running; determining whether the screen saver is a keyboard interactive and/or a mouse interactive screen saver; if the interactive screen saver is keyboard interactive and/or mouse interactive, then performing interactive operations within the interactive screen saver in response to user input entered from the keyboard and/or mouse, respectively without quitting the screen saver; and if the interactive screen saver is not keyboard and/or mouse interactive, then quitting the interactive screen saver in response to detecting the keyboard input and/or mouse input.
A better understanding of the present invention can be obtained from the following detailed description in conjunction with the following drawings, in which:
In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the embodiments of the invention described below. It will be apparent, however, to one skilled in the art that the embodiments of the invention may be practiced without some of these specific details. In other instances, well-known structures and devices are shown in block diagram form to avoid obscuring the underlying principles of the embodiments of the invention.
One embodiment of the invention comprises an interactive screen saver which, rather than terminating upon detecting user input, provides various types of interactive functionality. Specifically, in one embodiment, the interactive screen saver is designated as “mouse interactive” and/or “keyboard interactive,” allowing the user to interact with the screen saver via the mouse and/or keyboard, respectively. For keyboard interactive implementations, certain designated keys may be used for interaction while other keys (e.g., the ESC key) may be used to terminate the screen saver. In one specific implementation, the interactive screen saver creates images of album art and allows the user to select an album using the mouse and/or keyboard. In response to user selection of a particular album, a playlist for that album is automatically generated and played. Similarly, in one embodiment, the screen saver comprises a photo slideshow using the user's photo collection. The user select a particular photo from within the interactive screen saver to perform interactive operations such as opening a photo application, pausing the slideshow, and/or jumping between photos in the slideshow. As described below, various other implementations are contemplated within the scope of the present invention including, by way of example and not limitation, interactive videos, interactive calendars, and interactive messaging (e.g., new instant messages or email messages may be displayed and/or responded to).
As illustrated in
In one specific embodiment, the computer system is a Macintosh™ or MacBook™ running a version of the OS X operating system. In this implementation, the media framework 210 may be the iLife Media Browser Framework designed by Apple Inc.™, the assignee of the present application. Other media applications 203 may also access the user's content via the media framework. For example, the well known iTunes application (also designed by the assignee of the present application) accesses the user's music and album art 230 using the media framework. The interactive screen saver module 202 may communicate with the media applications 203 to access the user's content. For example, the interactive screen saver module 202 may communicate with media applications such as iTunes using AppleScript™, a well known scripting language designed by the assignee of the present application.
It should be noted, however, that the underlying principles of the invention are not limited to the specific implementations described above. Various different types of data processing devices and operating systems may be used including, but not limited to, portable data processing devices such as the iPhone, iPad, iPod Touch, and laptop computers.
One embodiment of an interactive screen saver method is illustrated in
Similarly, at 302b, mouse input is detected and, at 303b, a determination is made as to whether the screen saver is mouse interactive. If so, then at 304b, the interactive screen saver is controlled via the mouse. If not (or if a non-interactive mouse input is detected), then the screen saver quits at 301, and the data processing device returns to normal data processing operation.
As previously mentioned, in one specific embodiment, the interactive screen saver creates images of album art and allows the user to select an album using the mouse and/or keyboard. One embodiment of a method for implementing this interactive screen saver is illustrated in
Turning first to
At 404, an array is generated comprised of paths to each of the image artwork files. In one embodiment, the paths are simply file system links or URLs to the image files (e.g., JPEG images) on the user's local hard drive. In an iTunes implementation, the links may identify iTunes Cover Flow Data files (.itc files) which contain album artwork and metadata for songs and which are typically stored within the /Music/iTunes/Album Artwork/Local/directory.
Regardless of the particular format for the array of paths and art files, at 405, the array is randomized. That is, a first set of N album art images are randomly selected to fill N positions within the interactive screen saver. The value of N may be based on the number of rows of artwork displayed within the screen saver. As mentioned, this value may be configured by the end user.
At 406, the interactive screen saver displays the album artwork based on the size of the display screen and the number of rows of album art (e.g., as specified by the end user). The album images are then periodically swapped out with new images based on a time interval for rotating the artwork (which also may be specified by the end user). In one embodiment, a single, randomly selected album image is replaced with a new one at each time interval (e.g., every 2 seconds).
At 407, the selection of a particular album is detected. In one embodiment, the method shown in
A graphical user interface for one embodiment of an interactive screen saver is illustrated in
In one embodiment, after selecting a particular album, the interactive screen saver plays tracks from the album (either in order or randomly), and the album art image 601 displays a pause icon, as illustrated in
One embodiment of an interactive photo screen saver method is illustrated in
Regardless of the particular format for the array of paths and photo image files, at 704, the array is randomized. That is, a first set of N images may be randomly selected to fill N positions within the interactive screen saver. The value of N may be based on the user-specified number of images displayed within the screen saver. In one particular embodiment, only a single image at a time is displayed, but the screen saver randomly and periodically displays new images (e.g., every few seconds).
At 705, the interactive screen saver displays the photos based on the size of the screen, user-specified display parameters (e.g., number of concurrent photos to be displayed). The photo images are then periodically swapped out with new images based on a time interval (which also may be specified by the end user). In one embodiment, a single, randomly selected photo image is replaced with a new one at each time interval (e.g., every 2 seconds).
At 706, the selection of a particular photo is detected. In one embodiment, the method shown in
The interactive screen saver techniques described above may be implemented with various other types of user data and media content while still complying with the underlying principles of the invention. For example, a user's video collection may be automatically displayed in a similar manner to the photo embodiments described above. In addition, entries from a user's calendar may be displayed and the user may interact with these entries within the interactive screen saver via a mouse and/or keyboard (e.g., to delete entries, update existing entries, add new entries, etc). Similarly, in one embodiment, new email messages or instant messages may be displayed within the interactive screen saver. In one embodiment, the interactive screen saver rotates through each of the content types and/or types of data described above.
Throughout the foregoing description, for the purposes of explanation, numerous specific details were set forth in order to provide a thorough understanding of the invention. It will be apparent, however, to one skilled in the art that the invention may be practiced without some of these specific details. For example, while the embodiments described above focus on music and photo content, the underlying principles of the invention are not limited to any particular type of content. Accordingly, the scope and spirit of the invention should be judged in terms of the claims below.
Some embodiments include one or more application programming interfaces (APIs) in an environment with calling program code interacting with other program code being called through the one or more interfaces. Various function calls, messages or other types of invocations, which further may include various kinds of parameters, can be transferred via the APIs between the calling program and the code being called. In addition, an API may provide the calling program code the ability to use data types or classes defined in the API and implemented in the called program code.
At least certain embodiments include an environment with a calling software component interacting with a called software component through an API. A method for operating through an API in this environment includes transferring one or more function calls, messages, other types of invocations or parameters via the API.
One or more Application Programming Interfaces (APIs) may be used in some embodiments. An API is an interface implemented by a program code component or hardware component (hereinafter “API-implementing component”) that allows a different program code component or hardware component (hereinafter “API-calling component”) to access and use one or more functions, methods, procedures, data structures, classes, and/or other services provided by the API-implementing component. An API can define one or more parameters that are passed between the API-calling component and the API-implementing component.
An API allows a developer of an API-calling component (which may be a third party developer) to leverage specified features provided by an API-implementing component. There may be one API-calling component or there may be more than one such component. An API can be a source code interface that a computer system or program library provides in order to support requests for services from an application. An operating system (OS) can have multiple APIs to allow applications running on the OS to call one or more of those APIs, and a service (such as a program library) can have multiple APIs to allow an application that uses the service to call one or more of those APIs. An API can be specified in terms of a programming language that can be interpreted or compiled when an application is built.
In some embodiments the API-implementing component may provide more than one API, each providing a different view of or with different aspects that access different aspects of the functionality implemented by the API-implementing component. For example, one API of an API-implementing component can provide a first set of functions and can be exposed to third party developers, and another API of the API-implementing component can be hidden (not exposed) and provide a subset of the first set of functions and also provide another set of functions, such as testing or debugging functions which are not in the first set of functions. In other embodiments the API-implementing component may itself call one or more other components via an underlying API and thus be both an API-calling component and an API-implementing component.
An API defines the language and parameters that API-calling components use when accessing and using specified features of the API-implementing component. For example, an API-calling component accesses the specified features of the API-implementing component through one or more API calls or invocations (embodied for example by function or method calls) exposed by the API and passes data and control information using parameters via the API calls or invocations. The API-implementing component may return a value through the API in response to an API call from an API-calling component. While the API defines the syntax and result of an API call (e.g., how to invoke the API call and what the API call does), the API may not reveal how the API call accomplishes the function specified by the API call. Various API calls are transferred via the one or more application programming interfaces between the calling (API-calling component) and an API-implementing component. Transferring the API calls may include issuing, initiating, invoking, calling, receiving, returning, or responding to the function calls or messages; in other words, transferring can describe actions by either of the API-calling component or the API-implementing component. The function calls or other invocations of the API may send or receive one or more parameters through a parameter list or other structure. A parameter can be a constant, key, data structure, object, object class, variable, data type, pointer, array, list or a pointer to a function or method or another way to reference a data or other item to be passed via the API.
Furthermore, data types or classes may be provided by the API and implemented by the API-implementing component. Thus, the API-calling component may declare variables, use pointers to, use or instantiate constant values of such types or classes by using definitions provided in the API.
Generally, an API can be used to access a service or data provided by the API-implementing component or to initiate performance of an operation or computation provided by the API-implementing component. By way of example, the API-implementing component and the API-calling component may each be any one of an operating system, a library, a device driver, an API, an application program, or other module (it should be understood that the API-implementing component and the API-calling component may be the same or different type of module from each other). API-implementing components may in some cases be embodied at least in part in firmware, microcode, or other hardware logic. In some embodiments, an API may allow a client program to use the services provided by a Software Development Kit (SDK) library. In other embodiments an application or other client program may use an API provided by an Application Framework. In these embodiments the application or client program may incorporate 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. An Application Framework may in these embodiments provide a main event loop for a program that responds to various events defined by the Framework. The API allows the application to specify the events and the responses to the events using the Application Framework. In some implementations, an API call can report to an application the capabilities or state of a hardware device, including those related to aspects such as input capabilities and state, output capabilities and state, processing capability, power state, storage capacity and state, communications capability, etc., and the API may be implemented in part by firmware, microcode, or other low level logic that executes in part on the hardware component.
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 from the API-implementing component) that communicates with the API-implementing component through the API over a network. It should be understood that an API-implementing component may also act as an API-calling component (i.e., it may make API calls to an API exposed by a different API-implementing component) and an API-calling component may also act as an API-implementing component by implementing an API that is exposed to a different API-calling component.
The API may allow multiple API-calling components written in different programming languages to communicate with the API-implementing component (thus the 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 in terms of a specific programming language. An API-calling component can, in one embedment, call APIs from different providers such as a set of APIs from an OS provider and another set of APIs from a plug-in provider and another set of APIs from another provider (e.g. the provider of a software library) or creator of the another set of APIs.
It will be appreciated that the API-implementing component 510 may include additional functions, methods, classes, data structures, and/or other features that are not specified through the API 1120 and are not available to the API-calling component 1130. It should be understood that the API-calling component 1130 may be on the same system as the API-implementing component 1110 or may be located remotely and accesses the API-implementing component 1110 using the API 1120 over a network. While
The API-implementing component 1110, the API 1120, and the API-calling component 1130 may be stored in a tangible machine-readable storage medium, which includes any mechanism for storing information in a form readable by a machine (e.g., a computer or other data processing system). For example, a tangible machine-readable storage medium includes magnetic disks, optical disks, random access memory (e.g. DRAM); read only memory, flash memory devices, etc.
In
Note that the Service 2 has two APIs, one of which (Service 2 API 1) receives calls from and returns values to Application 1 and the other (Service 2 API 2) receives calls from and returns values to Application 2. Service 1 (which can be, for example, a software library) makes calls to and receives returned values from OS API 1, and Service 2 (which can be, for example, a software library) makes calls to and receives returned values from both OS API 1 and OS API 2. Application 2 makes calls to and receives returned values from OS API 2.
Any one of the methods described herein can be implemented on a variety of different data processing devices, including general purpose computer systems, special purpose computer systems, etc. For example, the data processing systems which may use any one of the methods described herein may include a desktop computer or a laptop computer or a tablet computer or a smart phone, or a cellular telephone, or a personal digital assistant (PDA), an embedded electronic device or a consumer electronic device.
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 invention as set forth in the following claims. The specification and drawings are, accordingly, to be regarded in an illustrative sense rather than a restrictive sense.
