Patent Publication Number: US-8977723-B2

Title: Cloud based application fragmentation

Description:
PRIORITY CLAIM 
     This application is a continuation-in-part of U.S. patent application Ser. No. 13/865,515, entitled “MOBILE DEVICE APPLICATION STREAMING” filed on Apr. 18, 2013, which claims benefit to U.S. Provisional Patent Application No. 61/708,794, entitled “cloud COMPUTING INTEGRATED OPERATING SYSTEM”, filed on Oct. 2, 2012, all of which are incorporated by reference herein in their entirety. 
    
    
     FIELD OF THE INVENTION 
     At least one embodiment of the present invention pertains to mobile device applications, and more particularly, to streaming of mobile applications designed to run on mobile devices. 
     BACKGROUND 
     In recent years, the use of wireless networks to distribute content within a service area thereof has become increasingly common. For example, a mobile device within range of a base station of a third generation (3G) or fourth generation (4G) cellular network is capable of “pulling content” from a remote server, for example, a content server, coupled to the base station. A mobile device can download a mobile application from an application distribution platform via a wireless network such as a WiFi or cellular network. Even with the increasing network speed of the modern WiFi and cellar networks, it can still take a significant time to download a large mobile application. A user of the mobile device has to wait for the download to be finished before the user can start installing and running the mobile application on the mobile device. Even for a user only wants to try a small percentage of the functionalities or stages of a mobile application, the user still need to download the whole application before the user can try any portion of the application. 
     Furthermore, a modern application can include a large amount multimedia content and can have a size of several gigabytes (GBs). A user of a mobile device may find that the mobile device does not have enough available storage space to accommodate the application. Therefore, the user may be forced to delete some of the existing applications or files stored on the mobile device, in order to run the application. 
     SUMMARY 
     Technology introduced here provides a mechanism to enable a user to run an application on a computing device before the whole application has been downloaded to the computing device. A processing server can decompose an application into a plurality of fragments. Each fragment of the application corresponds to one or more user interfaces, such as activities in an Android environment or views in an iOS environment. Resources are determined for each user interface. Resources, e.g. images, texts, videos, audios, 3D models, necessary for a specific user interface are included within a corresponding fragment. The dependency relationships between the fragments are also determined. 
     An application can be launched on a computing device by streaming one of more fragments of the application to the computing device. Fragments are streamed to and cached on the computing device based on the dependency of the fragments. For example, assuming fragments  5  and  6  can be only accessed via fragment  4 , if the user is currently active on fragment  4 , then fragments  5  and  6  may be prioritized for streaming to the computing device. A server can further determine the probability of each fragment being used based on other users&#39; access patterns. 
     The application can be decomposed into fragments using a full server processing method. For example, a processing server can run an emulator to execute the application and determine the user interfaces and resources for each fragment of the application. The application can also be decomposed into fragments using a crowd sources device processing. Computing devices that have the full application stored locally can run the application and determine the user interfaces and resources for each fragment of the application. Then the fragmenting information can be updated to a server so that the server can decompose the application on the server accordingly. 
     Other aspects of the technology introduced here will be apparent from the accompanying figures and from the detailed description which follows. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       These and other objects, features and characteristics of the present invention will become more apparent to those skilled in the art from a study of the following detailed description in conjunction with the appended claims and drawings, all of which form a part of this specification. In the drawings: 
         FIG. 1  illustrates an example system for streaming applications to computing devices. 
         FIG. 2  illustrates an example operating system of a computing device. 
         FIG. 3  illustrates an example of an application fragmentation analyzer. 
         FIG. 4  illustrates an example of an application fragmentation process. 
         FIG. 5  illustrates an example of a process for receiving and running fragments of an application. 
         FIG. 6  is a high-level block diagram showing an example of the architecture of a computer, which may represent any computing device or server described herein. 
     
    
    
     DETAILED DESCRIPTION 
     References in this specification to “an embodiment,” “one embodiment,” or the like, mean that the particular feature, structure, or characteristic being described is included in at least one embodiment of the present invention. Occurrences of such phrases in this specification do not all necessarily refer to the same embodiment, however. 
       FIG. 1  illustrates an example system for streaming applications computing devices. The system includes a cloud storage service  110  configured to store applications and determine fragmentation of the applications. In one embodiment, the cloud storage service  110  can be a storage cluster having computer nodes interconnected with each other by a network. The storage cluster can communicate with other computing devices via the Internet. The cloud storage service  110  contains storage nodes  112 . Each of the storage nodes  112  contains one or more processors  114  and storage devices  116 . The storage devices can include optical disk storage, RAM, ROM, EEPROM, flash memory, phase change memory, magnetic cassettes, magnetic tapes, magnetic disk storage or any other computer storage medium which can be used to store the desired information. 
     A cloud streaming interface  120  can also be included to stream fragments of applications from the cloud storage service to the computing device. The cloud streaming interface  120  can include network communication hardware and network connection logic to receive the information from computing devices. The network can be a local area network (LAN), wide area network (WAN) or the Internet. The cloud streaming interface  120  may include a queuing mechanism to organize fragments to be streamed to the computing devices. The cloud streaming interface  120  can communicate with the cloud storage service  110  to send requests to the cloud storage service  110  for requesting fragments of the applications. 
     A computing device  130  includes an operating system  132  to manage the hardware resources of the computing device  130  and provides services for running computer applications  134 . The computer applications  134  stored in the computing device  130  require the operating system  132  to properly run on the device  130 . The computing device  130  can backup application states of the computer applications  134  to the cloud storage service  110 . The computing device  130  includes at least one local storage device  138  to store the computer applications, application fragments, and user data. The computing device  130  or  140  can be a desktop computer, a laptop computer, a tablet computer, an automobile computer, a game console, a smart phone, a personal digital assistant, or other computing devices capable of running computer applications, as contemplated by a person having ordinary skill in the art. 
     The computer applications  134  stored in the computing device  130  can include applications for general productivity and information retrieval, including email, calendar, contacts, and stock market and weather information. The computer applications  134  can also include applications in other categories, such as mobile games, factory automation, GPS and location-based services, banking, order-tracking, ticket purchases or any other categories as contemplated by a person having ordinary skill in the art. 
     The operating system  132  of the computing device  130  includes a fragmentation processing module  136  to process the application fragments streamed from the cloud storage server  110 . Similarly, another computing device  140  can also retrieve application fragments from the cloud storage service  110 . 
       FIG. 2  illustrates an example operating system of a computing device, according to one embodiment. The operating system  200  includes a kernel  204 . The kernel  204  provides interfaces to hardware of the electronic device for the computer applications running on top of the kernel  204 , and supervises and controls the computer applications. The kernel  204  isolates the computer applications from the hardware. The kernel  204  may include one or more intervening sources that can affect execution of a computer application. In one embodiment, the kernel  204  includes a network I/O module  206 , a file I/O module  208 , multi-threading module  210 , user input  214 , system interrupts  216 , and shared memory access  218 . 
     A fragmentation processing module  230  runs on top of the kernel  204 . The fragmentation processing module  230  processes the application fragments retrieved from the cloud storage service and runs the application as that the entire application has been stored in the computing device. In the example of  FIG. 2 , a fragments cache  240  includes a current fragment  242  that currently run on top of the operating system  300 . The fragments cache  240  can further include a next fragment  244  that is ready to start seamlessly after the current fragment  242 . 
       FIG. 3  illustrates an example of an application fragmentation analyzer. The application fragmentation analyzer can be used by a storage server or a cloud storage service, such as the cloud storage service  110  as illustrated in  FIG. 1 . For example, the application fragmentation analyzer can run on the cloud storage service  110  to decompose an application into fragments. As illustrated in  FIG. 3 , the application fragmentation analyzer  300  includes an emulator  310  to execute the application determine the user interfaces and resources for each fragment of the application. The emulator  310  simulates an environment as a computing device on which the application runs. 
     By running the application on the emulator  310 , the application fragmentation analyzer  300  can determine a plurality of fragments of the application. Each fragment corresponds to one or more user interfaces of the application. For example, for an Android application, a user interface can include an activity of the Android application. For an iOS application, a user interface can include a view of the iOS application. For a HTML5 application, a user interface can include a page of the HTML5 application. 
     Once the fragments are determined, the application fragmentation analyzer  300  further generates a fragments relationship data structure  320 . The fragments relationship data structure  320  includes the information whether a fragment can lead (“link”) to another fragment during the operation of the application. For example, assuming fragments  5  and  6  can be accessed via fragment  4 , the fragments relationship data structure  320  can includes information that fragment  4  can lead to fragments  5  and  6 . 
     The application fragmentation analyzer  300  can further generate a resource dependency data structure  330 . The resource dependency data structure  330  includes information regarding the resources needed for running each fragment of the application. The resources can include images, icons, texts, audios, videos, 3D models, or other data included in the application. For instance, if a fragment  3  of the application needs to display an image A and play an audio clip B during the operation of the fragment  3  of the application, the resource dependency data structure  330  includes information that fragment  3  needs the image A and audio clip B. 
     Based on the information in the fragments relationship data structure  320  and the resource dependency data structure  330 , the application fragmentation analyzer  300  can generate the fragments of the application in a fragments store  340 . The fragments store  340  includes all the fragments of the application. In one embodiment, each specific fragment can include the resources that the specific fragment needs. In another embodiment, a fragment does not include all resources that the fragment needs. When the fragment is transmitted to a computing device, the corresponding resources are transmitted along with the fragment according to the resource dependency data structure  330 . 
     The application fragmentation analyzer  300  decomposes an application into fragments. A computing device can download enough fragments to run the application at the current status, instead of downloading the entire application. The computer device can further download and cache the fragments that would possibly follows the fragment currently running. 
     The application fragmentation analyzer  300  automatically determines the fragments of the application, without human intervention. The developer of the application does not need to do any extra work for decomposing the application into fragments. The application fragmentation analyzer  300  automatically determines the fragments based on the flow of the application and the resources dependency information. 
     In some other embodiments, the application fragmentation analyzer can be used by as a crowd sources device processing. Computing devices that have the full application or a portion of the application stored locally can use the application fragmentation analyzer to determine the user interfaces and resources for each fragment of the application. Then the fragmenting information can be updated to a server so that the server can decompose the application on the server accordingly and streams the fragments to the next requesting computing device. The computing device does not need to determine all fragments of the application. A first computing device can just determine a portion of the application that it has run locally into fragments. This fragmenting information is collected to the server. A second computing device can stream the fragments and may possibly run an even larger portion of the application. The second computing device can generate additional fragments that the first computing device does not generate. Collectively, computing devices can generate the fragments of the application so that the server just needs to use the fragmenting information to stream the fragments to a device that requests the application in the future. 
     In one embodiment, the fragments of the application can be in native code format for the operating system of the computing device. In another embodiment, the fragments can be in an interpretative or markup language such as HTML5 (HyperText Markup Language 5). 
     In one embodiment, the operating system of the computing device includes a fragment module to process and execute the fragments. For instance, when a fragment of an application ends the operation of the fragment and leads to another fragment, the fragment module can immediately stops and cleans up the fragment, and starts running the other fragment. In another embodiment, the computing device runs a launcher program to manage the operations of the fragments of the application. For instance, the launcher program can determine that a running fragment now leads to another fragment, and accordingly starts launching the other fragment immediately. 
     The fragments can have different versions specifically for different types of client devices. For instance, the fragments can have both English and Chinese versions of the fragments, designed for computing devices with English or Chinese language preference, respectively. The fragments can have different versions for different types of devices, different operating systems, or different mobile operator. For instance, the fragments of an application can have two different versions designed for Android tablets running on Verizon mobile network, and iPhone smart phones running on AT&amp;T mobile network, respectively. 
     In some embodiments, the application fragmentation analyzer  300  can aggregate the data obtained from various computing devices of crowd sourced devices. For example, the application fragmentation analyzer  300  can aggregate a first set of application fragments, a first fragments relationship data structure and a first resource dependency data structure obtained from a first computing device with a second set of application fragments, a second fragments relationship data structure and a second resource dependency data structure obtained from the second computing device, respectively, to determine an aggregated fragmenting information. In some embodiments, such aggregated fragmenting information may be more accurate than the fragment information generated by executing the application using the emulator. The computing devices of the crowd sourced processors may be executing same portions of the application, or distinct portions of the application. 
     The computing devices can be classified into one or more device categories, each of the one or more categories having an associated weight. The categories can be defined based on one or more of (a) a form factor of a display of a computing device of the computing devices, (b) an operating system of the computing device, (c) a wireless carrier network on which the computing device is operating, (d) a user interface technology of the computer application on the computing device, or (e) a language of the application fragment executed by the computing device. 
     In some embodiments, the aggregation can be performed based on an aggregation policy. The aggregation policy can consider aggregating based on a weight of the one or more categories to which a computing device corresponds. For example, the aggregation policy may provide more weight to information received from devices that have a particular operating system since the number of devices with the particular operating system in the market is significantly more than the number of devices with other operating systems. 
     In some embodiments, the application fragmentation analyzer  300  can update the fragments relationship data structure based on the observed access pattern of the fragments in the computing devices of the crowd source processing. In some embodiments, the application fragmentation analyzer  300  can a predict a set of fragments that can be navigated from a current fragment using probability techniques on the observed access pattern of the fragments. The application fragmentation analyzer  300  can calculate, for each of the fragments, probability values that indicate a probability of navigating to each of the other fragments. A fragment that has highest probability of being accessed following the current fragment is queued up for transmission to the computing device. 
     The downloading and caching of the fragments can be dynamically determined by various factors of the computing device. The computing device can monitor the operation of the currently running fragments and predict the next possible fragments to be cached. The computing device can adjust the fragments streaming queue based on the current network transferring speed and the workload of the computing device. 
     In some embodiments, the computing device can purge (“delete”) the fragments that have already been executed and are no longer needed for the current and future operation of the application. This saves the storage space and the computing device and can increase the cache space for caching the incoming fragments for potential future operation of the application. 
       FIG. 4  illustrates an example of an application fragmentation process. The process  400  can be performed by a server, or a computing device as a part of the crowd sourced processing. Although in the embodiment illustrated in  FIG. 4 , steps are performed by a server, the steps can also be performed by a computing device. At step  405  of the process  400 , the server runs a computer application in a simulated environment of a mobile device. At step  410 , by running the computer application in the simulated environment, the server determines multiple application fragments of a computer application. Each application fragment of the application fragments includes a code to present at least one interface of the computer application. 
     At step  420 , the server generates a fragments relationship data structure. The fragments relationship data structure includes identifications of application fragments that leads to another application fragment of the application fragments. At step  430 , the server stores the application fragments at a storage device within the server. 
     At step  440 , the server generates a resource dependency data structure, wherein for each specific application fragment of the application fragments, the resource dependency data structure includes identifications of resources that are needed for running the specific application fragment. The resources can include images, icons, texts, audios, videos, 3D models, or other data included in the computer application. 
     In one embodiment, at step  450 , for each specific application fragment of the application fragments, the server incorporates resources that are needed for running the specific application fragment into the specific application fragment, based on the resource dependency data structure. In another alternative embodiment, the resources are not incorporated in the fragments. Instead, the server streams, via the network component, resources that are needed for running the application fragment to the computing device, based on the resource dependency data structure. 
     At step  460 , the server streams, via a network component, an application fragment of the application fragments to a computing device, wherein the application fragment can potentially follow another application fragment currently running on the computer device based on the fragments relationship data structure. 
       FIG. 5  illustrates an example of a process for receiving and running fragments of an application. At step  505  of the process  500 , the computing device runs a first fragment of the computer application as a running instance of a computer application. At step  510 , the computing device receives a fragments relationship data structure. The fragments relationship data structure includes identifications of fragments that leads to another fragment of the computer application. 
     At step  515 , the computing device sends a request, to a server, for fragments to which the operation of the first fragment can potentially leads. At step  520 , the computing device receives, from a server, a second fragment of the computer application, wherein operation of the first fragment can potentially leads to the second fragment. 
     At step  525 , the computing device receives a resource dependency data structure. The resource dependency data structure includes identifications of resources that are needed for running fragments of the computer application. At step  530 , the computing device receives resources that are needed for running the second fragment, based on the resource dependency data structure. Alternatively, in some other embodiments, the second fragment itself includes resources that are needed for running the second fragment. 
     At step  535 , the computing device receives a signal indicating that the running instance of the computer application transitions from the first fragment to the second fragment. At step  540 , in response to the signal, the computing device stops the first fragment from running. At step  545 , in response to the signal, the computing device launches the second fragment. 
     In some other embodiments, a computing device can run a container application responsible for managing, launching and closing the fragments of a computer application. The computing device receives a first fragment of the computer application from a server. Under the control of the container application, the computer device executes the first fragment. The container application can executes the first fragment within the container application itself; or the container application send commands to the operating system of the computing device to execute the first fragment. 
     Either the container application or the server determines the next fragment that potentially follows the first fragment. In one embodiment, the container application determines a second fragment of the computer application that follows the first fragment, based on a fragments relationship data structure; then the container application requests and receives the second fragment of the computer application from the server. In another embodiment, the container application generates and sends a request to the server for fragments to which an operation of the first fragment can potentially leads; then receives a second fragment determined by the server. 
     When the first fragment of the computer application ends its execution, the container application launches the second fragment accordingly to continue the execution of the computer application. Therefore, under the control of the container application, the computer application can run seamlessly on the computer device without the need that all fragments of the computer application has to be downloaded to the computing device. The container application can further delete ended fragments (e.g. the first fragment) from the computing device to save local storage space. 
       FIG. 6  is a high-level block diagram showing an example of the architecture of a computer  600 , which may represent any computing device or server described herein. The computer  600  includes one or more processors  610  and memory  620  coupled to an interconnect  630 . The interconnect  630  shown in  FIG. 6  is an abstraction that represents any one or more separate physical buses, point to point connections, or both connected by appropriate bridges, adapters, or controllers. The interconnect  630 , therefore, may include, for example, a system bus, a Peripheral Component Interconnect (PCI) bus or PCI-Express bus, a HyperTransport or industry standard architecture (ISA) bus, a small computer system interface (SCSI) bus, a universal serial bus (USB), 11C (12C) bus, or an Institute of Electrical and Electronics Engineers (IEEE) standard 1394 bus, also called “Firewire”. 
     The processor(s)  610  is/are the central processing unit (CPU) of the computer  600  and, thus, control the overall operation of the computer  600 . In certain embodiments, the processor(s)  610  accomplish this by executing software or firmware stored in memory  620 . The processor(s)  610  may be, or may include, one or more programmable general-purpose or special-purpose microprocessors, digital signal processors (DSPs), programmable controllers, application specific integrated circuits (ASICs), programmable logic devices (PLDs), trusted platform modules (TPMs), or the like, or a combination of such devices. 
     The memory  620  is or includes the main memory of the computer  600 . The memory  620  represents any form of random access memory (RAM), read-only memory (ROM), flash memory, or the like, or a combination of such devices. In use, the memory  620  may contain a code  670  containing instructions according to the technology disclosed herein. 
     Also connected to the processor(s)  610  through the interconnect  630  are a network adapter  640  and a storage adapter  650 . The network adapter  640  provides the computer  600  with the ability to communicate with remote devices, over a network and may be, for example, an Ethernet adapter or Fibre Channel adapter. The network adapter  640  may also provide the computer  600  with the ability to communicate with other computers. The storage adapter  650  allows the computer  600  to access a persistent storage, and may be, for example, a Fibre Channel adapter or SCSI adapter. 
     The code  670  stored in memory  620  may be implemented as software and/or firmware to program the processor(s)  610  to carry out actions described above. In certain embodiments, such software or firmware may be initially provided to the computer  600  by downloading it from a remote system through the computer  600  (e.g., via network adapter  640 ). 
     The techniques introduced herein can be implemented by, for example, programmable circuitry (e.g., one or more microprocessors) programmed with software and/or firmware, or entirely in special-purpose hardwired circuitry, or in a combination of such forms. Special-purpose hardwired circuitry may be in the form of, for example, one or more application-specific integrated circuits (ASICs), programmable logic devices (PLDs), field-programmable gate arrays (FPGAs), etc. 
     Software or firmware for use in implementing the techniques introduced here may be stored on a machine-readable storage medium and may be executed by one or more general-purpose or special-purpose programmable microprocessors. A “machine-readable storage medium”, as the term is used herein, includes any mechanism that can store information in a form accessible by a machine (a machine may be, for example, a computer, network device, cellular phone, personal digital assistant (PDA), manufacturing tool, any device with one or more processors, etc.). For example, a machine-accessible storage medium includes recordable/non-recordable media (e.g., read-only memory (ROM); random access memory (RAM); magnetic disk storage media; optical storage media; flash memory devices; etc.), etc. 
     The term “logic”, as used herein, can include, for example, programmable circuitry programmed with specific software and/or firmware, special-purpose hardwired circuitry, or a combination thereof. 
     In addition to the above mentioned examples, various other modifications and alterations of the invention may be made without departing from the invention. Accordingly, the above disclosure is not to be considered as limiting and the appended claims are to be interpreted as encompassing the true spirit and the entire scope of the invention.