Shared software library for computing devices

Abstract

This application relates to shared software libraries for computing devices. Apparatuses and methods related to stored software libraries are provided. A computing device can receive versioned shared library information for a first software library used by a software application, where the versioned shared library information can include an identifier. The computing device can determine whether the computing device stores a copy of the first software library identified in the versioned shared library information by the identifier. The computing device can send a request for one of a full executable and a stripped executable for the software application, where the full executable includes the first software library and the stripped executable does not include the first software library. In response to the request, the computing device can receive the full executable or the stripped executable for the software application.

Description

[0001] Case Analysis

[0002] This application is a divisional application of Chinese invention patent application 201780059025.0, filed on October 18, 2017.

[0003] This patent application claims priority to U.S. Provisional Patent Application No. 62 / 471,298, filed March 14, 2017, entitled “Shared Software Libraries for Computing Devices,” the contents of which are incorporated herein by reference in their entirety for various purposes. Technical Field

[0004] This application relates to shared software libraries for computing devices. Background Technology

[0005] Many computing devices, including mobile computing devices, can run application software to perform various functions, such as communication-related functions, data manipulation functions, image generation and / or rendering functions, audio generation and / or rendering functions, and other functions. Application software can be downloaded or transferred to a computing device from a server or other computing device. In some cases, application software can be downloaded as part of a software package. A software package may include the application software and instructions for installing the application software. For example, the software package may be executable to execute instructions for installing the application software.

[0006] Some software applications may depend on functionality contained in one or more software libraries. Example software libraries include software with input / output capabilities, graphical user interface capabilities, operating system interface capabilities, memory management capabilities, mathematical functions, and other functionalities. For instance, a software application may be stored in an executable file that includes the software libraries used by the application. Summary of the Invention

[0007] In one aspect, a method is provided. A computing device receives versioned shared library information of at least a first software library used by a software application, wherein the versioned shared library information of the first software library includes an identifier of the first software library. The computing device determines whether it stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information. Based on whether the computing device stores a copy of the first software library, the computing device sends a request for one of a full executable file and a stripped executable file for the software application, wherein the full executable file includes at least the first software library, and wherein the stripped executable file does not include the first software library. In response to the request, the computing device receives either the full executable file or the stripped executable file for the software application for storage on the computing device.

[0008] In another aspect, a computing device is provided. The computing device includes: one or more processors; and a data storage, including at least computer-executable instructions stored thereon, which, when executed by the one or more processors, cause the computing device to perform a function. The function includes: receiving versioned shared library information of at least a first software library used by a software application, wherein the versioned shared library information of the first software library includes an identifier of the first software library; determining whether the computing device stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information; based on whether the computing device stores a copy of the first software library, sending a request for one of a complete executable file and a stripped executable file of the software application, wherein the complete executable file includes the first software library, and the stripped executable file does not include the first software library; and in response to the request, receiving either the complete executable file or the stripped executable file of the software application for storage on the computing device.

[0009] In another aspect, a computer-readable medium is provided. Instructions are stored on the computer-readable medium that, when executed by one or more processors of a computing device, cause the computing device to perform a function. The function includes: receiving versioned shared library information of at least a first software library used by a software application, wherein the versioned shared library information of the first software library includes an identifier of the first software library; determining whether the computing device stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information; based on whether the computing device stores a copy of the first software library, sending a request for one of a complete executable file and a stripped executable file of the software application, wherein the complete executable file includes the first software library, and the stripped executable file does not include the first software library; and in response to the request, receiving either the complete executable file or the stripped executable file of the software application for storage on the computing device.

[0010] In another aspect, an apparatus is provided. The apparatus includes: means for receiving versioned shared library information of at least a first software library used by a software application, wherein the versioned shared library information of the first software library includes an identifier of the first software library; means for determining whether a computing device stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information; means for sending a request for one of a full executable file and a stripped executable file of the software application based on whether the computing device stores a copy of the first software library, wherein the full executable file includes the first software library and the stripped executable file does not include the first software library; and means for receiving, in response to the request, the full executable file or the stripped executable file of the software application for storage on the computing device.

[0011] The foregoing description of the invention is merely illustrative and is not intended to be limiting in any way. Other aspects, embodiments, and features, in addition to those described above, will become apparent from the accompanying drawings and the following detailed description. Attached Figure Description

[0012] Figure 1 A software package stored by an app store is shown according to an example embodiment.

[0013] Figure 2 A workflow based on an example embodiment is shown.

[0014] Figure 3A and 3B The illustration depicts a scenario involving the creation and installation of software applications using software packages and shared repositories, according to an example embodiment.

[0015] Figure 4 A distributed computing architecture based on an example embodiment is described.

[0016] Figure 5A This is a functional block diagram of a computing device according to an example embodiment.

[0017] Figure 5B A network of computing clusters arranged as a cloud-based server system according to an example embodiment is described.

[0018] Figure 6 This is a flowchart of a method according to an example embodiment. Detailed Implementation

[0019] Technologies and devices for shared software libraries

[0020] Software applications can be written as source code in one or more computer languages. In some cases, the source code of a software application can be compiled, and the compiled source code can be stored in an executable file. The compiled code in the executable file can be executed by a computing device to perform various functions of the software application. Some of these functions can be stored in one or more software libraries. Then, as part of creating the executable file of the software application, one or more software libraries can be "linked" with the compilation instructions of the source code. These software libraries can be statically linked; that is, the software libraries are included in the executable file. Note that unless the context clearly indicates otherwise, the terms "library" and "executable" refer to the software library and the executable file, respectively, throughout this specification.

[0021] However, if multiple applications use a common library, static linking of the common library can create multiple copies of the common library, wasting storage space intended for storing copies of the same common library. In a study involving a sample of over 10,000,000 installed software applications, it was found that mobile computing device applications each used approximately 1 megabyte (MB) of storage to store the library. Many of these libraries were used by multiple applications, with the most frequently used libraries used by over 90% of the sampled installed applications, and at least 10% of the sampled installed software applications using at least five libraries. Furthermore, the size of the libraries can grow over time; for example, the study also showed that library sizes grew by approximately 50% over three years, meaning that mobile computing device applications could use more than 1.5 MB (or more) of storage per application to store the library over several years. According to one estimate, if three or more applications share a common library stored once on a computing device, the storage required to store one copy of the shared common library for three or more applications is less than the storage required to store three or more applications, each with a link to the common library. Therefore, even relatively little library sharing—that is, library sharing among at least three applications—can save storage space, and these savings can grow over time.

[0022] Another technique for linking libraries is dynamic linking libraries; that is, the library is loaded into memory at runtime. Specifically, the executable instructions corresponding to the source code of the software application are loaded into memory, and then the library is loaded into memory. If a library is already loaded into memory (for example, if another application is using the library), one or more memory references to the already loaded library can be resolved, or the memory address of the already loaded library can be referenced. Then, if only one copy of the library is stored on the computing device, and the library is then dynamically loaded, storage space can be saved.

[0023] However, dynamic loading can become difficult as libraries evolve. Typically, dynamically loading a named library involves loading at least a portion of the named library at runtime. In some cases, a library can be "backward compatible"; that is, a newer version of the library supports all (or at least most) the functionality of one or more previous versions of the library. Maintaining backward compatibility can be difficult as libraries evolve because reorganization and / or new features may alter previous functionality. If the library is not truly backward compatible, these changes can cause previously working software applications that rely on functionality implemented in earlier versions of the library to malfunction.

[0024] If you build an application using statically linked libraries, you can guarantee the use of a specific version of the library because the software application developer or other author can generate an executable file that includes a specific version of the library. As mentioned above, static linking of libraries allows software application developers to control library compatibility, at the cost of (potentially) wasted library storage space.

[0025] This document discloses technologies and apparatuses for storing, accessing, loading / using, and managing versioned shared libraries. These technologies enable software developers to specify one and only one version of a shared library for dynamic loading and other purposes, even if multiple versions of the shared library are available. That is, a computing device can use a shared library to emulate a statically linked library by (a) ensuring that one or more versions of the shared library are installed on the computing device, and then (b) allowing the application to specify precisely which version of the shared library will be dynamically linked to the application at runtime.

[0026] Using dynamically loaded shared libraries reduces the likelihood of multiple copies of the same version of a library being stored on computing devices, thus saving storage. Furthermore, using shared libraries can reduce executable file size because executables using shared libraries do not need to contain copies of those shared libraries. Reducing executable file size can decrease the size of the corresponding software package, thus speeding up application installation by enabling the download of smaller packages and reducing the time spent allocating and storing applications during download. Additionally, developers can specify which version of the library to use, maintaining control over library compatibility. Allowing the specification of a specific version of a shared library allows developers to design their applications as they have done so far, confident that the library will not have compatibility issues. Moreover, developers upgrading library software are less concerned about backward compatibility as long as older versions of shared libraries remain available.

[0027] In some environments, one or more "app stores" or distribution platforms for software applications may store software applications and one or more versions of one or more libraries used by the software applications, including versioned shared libraries that are partly specified by version information such as version numbers. The app store can then provide the software application and related libraries to a computing device upon request.

[0028] The app store may generate and / or provide multiple software packages; for example, a first package containing a stripped executable of app A and information specifying the use of one or more shared libraries, wherein the stripped executable does not include one or more shared libraries; and a second package containing the full executable of app A, including the shared libraries. Before downloading the first software package via a target device, the target device and / or one or more other computing devices can use the shared library information to determine whether the shared libraries are missing or already stored on the target device. Once the target device has copies of all the shared libraries listed in the shared library information, the target device can download the first software package. The second package may be provided to the target device when the use of one or more shared libraries is not feasible. For example, not all devices that download and install app A support the shared libraries; in these cases, such devices can download and install the second package to utilize the full executable of app A.

[0029] In some examples, partially complete executables can be used. A partially complete executable can share one or more software libraries and can include one or more other software libraries. For example, suppose the application A_HYBRID depends on two libraries: version V.1.1 of library L_HY1 and version V.1.1 of library L_HY2. Therefore, the application A_HYBRID can be associated with at least the following four possible packages: (1) a complete package with a full executable of A_HYBRID, (2) a stripped package with a stripped executable for A_HYBRID, which includes shared library information for versions V.1.1 of library L_HY1 and L_HY2, (3) a first-part complete package with a partially complete executable of A_HYBRID, which contains a copy of version V.1.1 of library L_HY1 and shared library information for version V.1.1 of library L_HY2, and (4) a second-part complete package with a partially complete executable of A_HYBRID, which contains a copy of version V.1.1 of library L_HY2 and shared library information for version V.1.1 of library L_HY1. In this example, it is further assumed that version V.1.1 of library L_HY2 is no longer supported as a shared library, while version V.1.1 of library L_HY1 is still supported as a shared library. This allows for the use of a second, complete package for download instead of either a stripped package or a first, complete package. Other examples of partially complete executables are also possible.

[0030] To generate a software package for an application that uses shared libraries, developers can provide one or more executable files of the application, along with shared library information. Shared library information can take the form of shared library metadata such as tags and / or other data. This shared library information is used to "build" or generate the executable file of the software application and ensure that the executable file can run; that is, to ensure that a copy of the specified shared library is available before the executable file is executed for the first time. For example, shared library information may include information about the exact shared library, including the library name, library version number, and / or other data about the exact shared library; for example, a hash value specific to the exact shared library.

[0031] One or more Application Programming Interfaces (APIs) enable app stores and / or other entities, such as app store clients running on the target device, to determine whether a shared library and / or a specific version of a shared library is missing from the computing device or has been stored on the computing device, such as the target device where the software package is downloaded. As mentioned above, the shared library information of the software package may include version control information. The API can then be used to obtain information for determining whether a specific version of a shared library specified in the shared library information is missing from the target device or has been stored on the target device. In some examples, when one or more shared libraries are missing from the target device, the target device can obtain the missing shared libraries from the app store; for example, during the app download process.

[0032] Software utilities can help generate and distribute software packages containing shared libraries. For example, an upload software utility can take a complete software package as input, containing a compiled copy of the application software and copies of any shared libraries used by the application software. Upon execution, the upload software utility can generate a corresponding stripped package, which includes the stripped executable and shared library information. The stripped executable can be a version of the complete executable without copies of the shared libraries, and the shared library information can provide information about the names and versions of the shared libraries removed to create the stripped executable. In some cases, the complete package may include shared library information about one or more possible shared libraries used by the application software. Therefore, the upload software utility can determine whether the shared library information is correct for each possible shared library (i.e., ensuring that the version of the library is actually usable as a shared library). If the information about the shared libraries is correct, the upload software utility can strip the shared libraries from the executable and provide the shared library information about the stripped shared libraries as part of the stripped package. In some examples, software compilation / build tools that may be different from the upload software utility can be used to generate the stripped executable, stripped package, shared library information, complete executable, and complete software package. For example, application developers can use these software compilation / build tools to generate executable files, packages, and shared library information without having to upload (or download) the information.

[0033] Upload software utilities can be associated with app stores, allowing developers to upload complete software packages. As part of the upload process, the app store can use the uploaded complete software package as input to invoke the upload software utility to generate one or more corresponding stripped packages. In some examples, shared library information may include build information for creating a single (binary) file containing shared library information, build information, software, resources, and other dependency information (e.g., information about which software components depend on other software components) for building the software application. The (binary) file can then be uploaded to the app store for the upload software utility to analyze, process, and generate the software package. In other examples, the upload process may involve the app store using the uploaded stripped package as input, along with the stripped executable and shared library information, to invoke the upload software utility to generate a corresponding complete software package including a full executable that includes copies of the libraries referenced in the stripped executable and shared library information.

[0034] After the software upload utility has been executed, the app store can then make the full and / or stripped packages available for subsequent downloads and installations. In some examples, the software upload utility can generate one or more full and / or stripped packages that have been customized for use with specific brand and / or model computing devices; for example, customized for screen size, available memory, processor, and / or other characteristics of the computing device. The software upload utility can simplify software distribution for applications because developers do not need to build multiple versions of the same application; instead, the utility can generate multiple customized packages for distributing the software application.

[0035] A software download utility can receive requests for application software and deliver a package suitable for use by the requesting device. In some examples, the software download utility may execute directly on the app store server; in other examples, the software download utility may be part of the app store client and / or other software executing on the requesting device that sent the request for the application software.

[0036] The download software utility can communicate with the requesting device to determine whether the requesting device can assume the use of shared libraries to provide a full software package or a stripped package. The download software utility can download and install the full software package if the requesting device does not support the use of shared libraries, or install the stripped package if the requesting device does support the use of shared libraries.

[0037] If the stripped package can be installed, the download software utility can verify that the requesting device has copies of versions of shared libraries that can be used in the stripped package. To perform this verification, the download software utility can examine the shared library information in the stripped package to see if the software application uses any shared libraries. The relevant software utility can then use version matching to compare any shared libraries used by the stripped package with a list of available shared libraries. If a version match is detected, the download software utility can, as needed, communicate with the version of the software utility running on the requesting device to determine if the matching shared library already resides on the device; and generate a stripped package that references the matching shared library by stripping the shared library from at least the full package.

[0038] If the requesting device is missing one or more matching shared libraries, those missing shared libraries can be downloaded from the app store during the installation of the strip package. If a package must be "patched" or updated to fix bugs and / or otherwise improve the software application and / or package, the patching software can support patches for both the stripped and full packages, depending on the type of package and / or its contents; for example, whether the patched library is present in the package. In some cases, software utilities can use a list of available shared libraries to verify the correctness of the package. For example, if the stripped package contains references to shared libraries not in the list of available shared libraries, the stripped package can be updated to remove those references.

[0039] Furthermore, app stores can limit or otherwise control the number of library versions supported at any given time. Limiting the number of versions available for shared libraries can be beneficial, as having too many versions of non-popular libraries and / or available versions of popular libraries can consume significant storage space for expanding the number of shared library versions.

[0040] To support the use of shared libraries, computing devices such as mobile computing devices may include data storage for the shared libraries and library management software for managing the stored shared libraries; for example, software for installing, removing, and maintaining information about the stored shared libraries, as well as APIs and / or other software that enables access to information about the shared libraries stored on the computing device. The library management software may include software that forcibly removes and / or garbage collects shared libraries; that is, removes shared libraries that have not been used for a period of time and / or have not been referenced as shared libraries by at least a threshold number of applications (e.g., one, two). The number of applications referencing a particular shared library SL1, also known as the “reference count” of shared library SL1, may be initialized to zero, incremented when a software application referencing SL1 is installed, and decremented when a software application referencing SL1 is uninstalled. The library management software may include software for replacing a stripped executable of a software application with a corresponding full executable that includes a copy of the shared library, enabling the removal of the shared library. For example, if only one application A1, stored on computing device CD1, references a specific version V1 of shared library SL1, then the library management software can replace A1's stripped executable SE1 with a full executable F1 containing a copy of version V1 of shared library SL1 from A1. The library management software can then remove the stored copy of version V1 of shared library SL1. In some cases, the library management software can generate a full executable F1 from the stripped executable SE1 and a copy of version V1 of shared library V1; after generating the full executable F1, the library management software can replace A1's stripped executable SE1 with A1's full executable F1.

[0041] Furthermore, reference counting can be used to determine whether a striped executable or a full executable should be downloaded. For example, if the reference count of a shared library is less than a threshold, indicating that at most a few applications will use or are likely to use the shared library, the full executable can be downloaded instead of the shared library. This indication of the likelihood of using a shared library can be based on additional criteria besides the corresponding reference count. Such criteria can include, but are not limited to, which applications are currently on the device, data on the use of shared libraries from other devices; for example, data based on what applications other devices are using and / or data on multiple downloads of shared library packages that include the shared library. Therefore, based on the reference count of the shared library and / or additional criteria, the device can determine whether to request a software package of an application with a stripped executable or a corresponding software package of an application with a corresponding full executable.

[0042] In some examples, one or more full executables can be replaced with corresponding stripped executables and one or more shared libraries. Continuing the example above, after the full executable F1 of A1 (including a V1 version copy of shared library SL1 and a storage copy of the V1 version of shared library SL1) has been removed from CD1, assume that two executables F2 and F3, each a stripped executable, have been downloaded and installed on CD1, and they depend on version V1 of shared library SL1 (i.e., utilize its functionality). Then, after installing shared library SL1 on CD1, the library management software can replace the full executable F1 of A1 with a copy of the stripped executable SE1 of A1.

[0043] In some examples, a library can be split or partially included to be used for stripping an executable. For example, suppose the shared library SL_PARTIAL includes software and related resources for ten different functions F1, F2... F10, and application A2 only uses the software and related resources for one function, F2. Therefore, if A2 is executed, one or more segments / parts of SL_PARTIAL, including the software and related resources for function F2, can be loaded at runtime. The stripped executable SE2 of A2 might then only have the related software and resources loaded from the library at runtime; for example, the software and resources for function F2. Conversely, the full executable of A2 will load all SL_PARTIAL at runtime. This difference can be mitigated by supporting resource splitting of statically shared libraries.

[0044] A shared library user interface, such as a graphical user interface (GUI) of a computing device, may include functionality related to providing information about the shared library and controls for the shared library. For example, a GUI and / or other user interface on computing device "CD1" may provide a shared library display listing the shared libraries currently installed on CD1. The shared library display may include relevant data about the shared library, such as, but not limited to: library version number, library creation and / or installation time, library size, information about applications utilizing the shared library, information about the functionality provided by the shared library, and information about the author and / or source of the shared library. The shared library user interface may provide one or more controls; for example, icons, buttons, menus, to enable the presentation of some or all of the relevant data about the shared library mentioned above. In some cases, a storage settings GUI or other GUI provided by the computing device may include a user interface for shared libraries.

[0045] The computing device may have test software for testing applications with shared library software. For example, the test software may list, download, install, and / or uninstall specific versions of one or more shared libraries. The test software may have an interface that provides dump commands, and platform logging may reference the shared libraries by their stored names. In some examples, the test software may be accessible through a shared library user interface.

[0046] During the installation of a stripped software package onto a computing device "CD," a query can be used to determine whether the CD stores one or more versions of one or more shared libraries. In some cases, the query can be restricted to a specific version of a shared library; that is, the query can be limited to versions of shared libraries referenced by the stripped package. For example, suppose a stripped package P depends on a library L, version v1, and two versions of the CD repository L—versions v1 and v2. A query run on behalf of the stripped package P for library L will then return that version v1 of library L is stored on the CD, but will not return that version v2 of library L is also stored on the CD. In these examples, a query run on behalf of a package that does not reference any shared libraries will not return any information about libraries stored on the CD. In other cases, the aforementioned download software utility may perform some or all of the functions required to perform the query to determine whether the CD stores one or more versions of one or more shared libraries listed in the shared library information of the package, such as the stripped package.

[0047] A library may or may not qualify as a shared library; for example, due to limitations such as testing a specific library, the storage of shared libraries, the number of shared libraries, and / or the number of versions available for shared libraries. For libraries that qualify as shared libraries, they can be specified by identifier and version; therefore, a qualified library can have a name or other identifier and include version information. In some examples, a library can be associated with verification information used to verify the data integrity of the library, such as one or more hashes, cryptographic hashes, and / or other information. In these examples, in particular, verification information can act as the identifier of the library; that is, in lieu of the library's name and / or version, or used in conjunction with the library's name and / or version. Furthermore, qualified libraries can be updated to include archives and other information used when building software applications, enabling applications to refer to qualified libraries as shared libraries.

[0048] When determining which versions of a library are eligible to be used as shared libraries, versions of libraries that are likely to be stable and do not break software applications can be prioritized over versions that are unlikely to be stable. For example, historical data about a particular library, SL2, might indicate that initial versions of SL2, such as V1.0, V2.0, etc., were likely unstable. Therefore, if we are considering whether a new version of SL2, V3.0, is eligible, historical data suggests that earlier versions of SL2 V3.0, such as V3.0, V3.0.1, and V3.0.2, might not be eligible as shared libraries, but based on later versions, such as SL2 V3.0.3, they might be eligible. Continuing this example, applications built against versions V3.0, V3.0.1, and V3.0.2 of SL2 can be packaged as a complete package with a statically linked copy of the SL2 library to the application executable, while applications built against SL2 version V3.0.3 can be packaged as a complete package with a copy of SL2 V3.0.3, or as a stripped-down package using the shared library SL2 version V3.0.3.

[0049] Applications built for V3.0.3 can be packaged as stripped packages, where the application executable does not include a linked copy of SL2's V3.0.3. In some examples, the application may need to explicitly specify the use of shared libraries when building the application. That is, to build a stripped package, developers may need to explicitly specify the use of the stripped application package at build time.

[0050] Subsequent versions of a library can be stable but not eligible for sharing. For example, such stable versions of a library may have a relatively short lifespan, with a relatively small number of fixes and / or may be limited based on the total number of supported versions of the library. Continuing the example above, suppose SL2 has later versions V3.0.4 and V3.0.5; both are considered stable, but only V3.0.5 is eligible to be used as a shared library. An application built against version V3.0.4 of SL2 can then be packaged as a complete package with a copy of SL2, V3.0.4 statically linked to the application executable, while an application built against version V3.0.5 of SL2 can be packaged as a complete package with a copy of SL2, V3.0.5 or as a stripped-down package using the shared library SL2 version V3.0.5. In some embodiments, an application built against version V3.0.3 of SL2 as a shared library will continue to use version V3.0.3 of SL2 as a shared library. In other embodiments, applications built for version 3.0.3 of SL2, which is a shared library, will be "upgraded" to use the latest version of SL2, namely version 3.0.5 of SL2, as a shared library.

[0051] In some of these other embodiments, the application can decide whether to use a specific version of the shared library or the latest version of the shared library. More specifically, an application using the shared library can declare a dependency on one or more versions of the shared library. A dependency can be specified using one of the following dependency types: Exact dependency type – requires a shared library of version 1.2.3 at build time, and precisely obtains the shared version 1.2.3 at runtime. Minimal dependency type – Requires a shared library of version 1.2.3 at build time and obtains version 1.2.3 or any later at runtime; that is, obtains a shared library that is at least the latest version of version 1.2.3. Maximum dependency type—requires a shared library version 1.3.2 at build time and obtains 1.3.2 or any earlier version at runtime; that is, obtains the latest version of the shared library no later than version 1.3.2. Combinations of minimum and maximum dependency types allow for specifying a window of library versions; for example, a library version no earlier than version 1.2.3 specified by the minimum dependency type and no later than version 1.3.2 specified by the maximum dependency type.

[0052] Template dependency types - using " The template for specifying the version number of the shared library using " and other characters, where " "Matches a string with zero or more characters. For example, use a template to ask for the version of a shared library, "1.2", during the build process." ", and obtain version 1.2 of the shared library. Any version (e.g., 1.2.0, 1.2.1, 1.2.1.1, 1.2.2, etc.) at runtime but not a shared library that does not match the template (e.g., 1.3, 1.3.2, 2.0, etc.)

[0053] Other dependency types are also possible.

[0054] In some examples, a shared library may depend on one or more other libraries, including one or more shared libraries. In these examples, dependencies between libraries can be declared. More specifically, if version v1 of shared library L1 depends on version v1.7.13a or higher of shared library L2, a dependency between L1 and L2 can be declared, where the dependency declaration includes information that version v1 of library L1 depends on library L2, with a minimum dependency type of version v1.7.13a. Other examples of dependencies between libraries are also possible.

[0055] Static shared libraries can be installed (or uninstalled) on a computing device in the same or similar manner as software applications are installed (or uninstalled). Typically, only one version of the software application is installed at a time; conversely, multiple versions of shared libraries can be installed simultaneously. Uninstalling a shared library can include specifications for one or more versions of the shared library to be uninstalled. An example specification for the object "PackageInstaller" used to uninstall a shared library is: public void PackageInstaller#uninstall(@NonNull VersionedPackageversionedPackage, @NonNull IntentSender statusReceiver); Installing a shared library may include determining the name of the stored shared library, which can be the name of one or more packages, files, directories, folders, and / or other storage entities used to store the shared library on a computing device. The stored shared library name can be a unique name based on the library name and / or library version. For example, if the library name is "foo.bar.baz", the stored shared library name could be "foo.bar.baz" or a related name; for example, "foo_bar_baz" with underscores replacing periods in the library name. As another example, if the library name is "foo.bar.baz" and the library version is "V1", the stored shared library name could be "foo.bar.baz_V1" or a related name. Because a shared library can be uniquely identified by its name and version, names generated in this way are unique.

[0056] In some cases, the stored shared library name may be a "composite" name used internally by the operating system and / or other system software of the computing device, but otherwise not disclosed. In other cases, the stored shared library name may be used both internally and externally; that is, the stored shared library may be visible outside the operating system and / or other system software. In still other cases, the name of the shared library used by the shared library user interface and / or test software may be based on the stored shared library name based on the library name and / or library version mentioned above; for example, a test / debugging interface that supports dump commands and platform logging may reference the shared library through the stored shared library name.

[0057] Using different stored shared library names for shared libraries can simplify the identification of specific library versions; for example, checking the stored shared library names "foo.bar.baz_V1" and "foo.bar.baz_V2" allows "foo.bar.baz_V1" to be identified as library version V1, and "foo.bar.baz_V2" as library version V2. In some examples, operations on stored libraries may rely on exact matching of library information. One such operation is updating a stored shared library, which only occurs if both the library name and version match exactly between the stored shared library name and version, and between the name and version of the update used for (presumably) the same shared library. Without such a match, the shared library may be updated incorrectly.

[0058] One or more APIs can be used to obtain information about libraries stored on a computing device. For example, an API can indicate whether a library is built into a software application (e.g., as part of the complete application), is dynamically loadable, or is shared. As another example, an API (and / or another API) can be used to obtain information about where shared libraries are stored on the computing device. Another example is a platform API used to query information about a specific version of a package and to unload the package—example platform APIs are shown in Table 1 below:

[0059] Table 1

[0060] Shared libraries can be stored in one or more repositories / partitions of a computing device's data storage. Each repository / partition can store one or more different versions of one or more different libraries. In some cases, library management software on the computing device can determine how many versions of a particular library to store. For example, the library management software can maintain a sliding window of X versions of a shared library (X > 0). Versions of shared libraries outside the sliding window can be removed or marked for static linking to the executable. Using a sliding window to store only the X latest versions of a shared library can incentivize developers to use one of those X latest versions of the shared library in their application software.

[0061] In some examples, uninstalling / removing an app may result in the removal of shared libraries used by the now-uninstalled app. In other examples, uninstalling / removing an app will not result in the removal of shared libraries used by the now-uninstalled app; instead, the removal of some or all of these shared libraries may be considered only if no apps currently installed reference them. Then, if the now-uninstalled app was the last app to reference a particular shared library (a particular version), the removal of that particular shared library (a particular version) may be considered.

[0062] In other examples, usage statistics can be collected on a per-device and / or per-library / per-partition basis. For instance, if a computing device's partitions store Y different versions of shared libraries, then each version Y can be considered as being used by the computing device to determine the usage statistics for the shared libraries. These usage statistics can be used to determine which libraries are suitable for pre-installation; that is, usage statistics can indicate which are the most frequently used (versions) of shared libraries, and then the most frequently used (versions) of shared libraries can be pre-installed on new devices.

[0063] An app store (or other entity) may include one or more web pages or other libraries and a list of their versions supported as shared libraries for applications using the app store (or other entity). The web page or other list for supported versions of a shared library may include one or more of the following: (a) a link to a supported version of the shared library; that is, enabling developers to download a supported version of the shared library for software development, testing, and / or building; (b) a hash and information about the supported version of the shared library; (c) information about building using the shared library, such as information about building strip packages that include a supported version of the shared library and / or creating strip executables that do not include a supported version of the shared library; and (d) other information about the supported version of the shared library, such as the shared library size, author / entity information about the library, creation and / or release date, library name, library version number, etc. In some cases, the web page / list may include information about multiple supported versions of a library; for example, for the shared library SL3, the web page / list may include information about versions 1.1 and 1.2 of SL3, assuming that versions 1.1 and 1.2 of SL3 are supported.

[0064] Figure 1 Packages 110 and 120, stored by one or more computing devices acting as a server for application store 100, are illustrated according to an example embodiment. Library package 110 can be used to provide one or more software libraries, such as included software library 112. Library package 110 also includes library information 114 for declaring attributes and / or providing data about software library 112. For example, library information 114 may include shared library metadata, such as one or more tags, containing data about software library 112.

[0065] The example "static-library" tag for version 1.2.3 that declares software library 112 as a static library named "foo.bar.lib" is: <static-library name="foo.bar.lib" version="1.2.3" / >. As shown above, the example "static-library" flag can specify the library name, such as "foo.bar.lib"; and the version number, such as "1.2.3".

[0066] Other software, such as application software, may depend on one or more libraries, such as software library 112. This dependency can be declared in shared library information, which is part of the software package providing the requested software. Figure 1An application package 120 is shown, which includes software application 122, shared library information 124, and application information 126. In some examples, shared library information 124 and / or application information 126 are not present in the application package 120.

[0067] Software application 122 may include one or more executable files having instructions that, when loaded into and executed by a computing device, cause the computing device to perform the functions of software application 122. The executable file may be a complete executable file or a stripped executable file. For example, a complete executable file may be an executable file that includes the instructions of software application 122 and instructions of one or more libraries; that is, a complete executable file may include some or all of software application 122 and one or more statically linked libraries. As another example, a stripped executable file may be an executable file that includes the instructions of software application 122, which depends on but does not include instructions of one or more software libraries; that is, a stripped executable file includes software applications that depend on one or more dynamically linked shared libraries not included in the stripped executable file.

[0068] Shared library information 124 can use one or more tags to declare that the software application 122 depends on one or more shared libraries. For example, an example tag declaring the use of version 1.2.3 of a static shared library named "foo.bar.lib" is: <uses-static-library name="foo.bar.lib" version="1.2.3" / > As shown above, the example “uses-static-library” flag can specify the library name, such as “foo.bar.lib”; and the version number, such as “1.2.3”.

[0069] In some examples, the above tags may include information about the digital certificate associated with the library. For instance, an example "uses-static-library" flag that includes the SHA-256 hash of the signing certificate associated with version "1.2.3" of the aforementioned "foo.bar.lib" library is: <uses-static-library> name="foo.bar.lib" version="1.2.3" certDigest="6C:EC:C5:0E:34:AE:31:BF:B5:67:89:86:D6:D6:D3:73:6C:57:1D:ED:2F…"> In the example above, the "certDigest" field of the "uses-static-library" tag includes the SHA-256 hash of the signing certificate associated with version "1.2.3" of the "foo.bar.lib" library. In some examples, key rotation may be supported when using a signing certificate. In other examples, the "certDigest" field of the "uses-static-library" tag may include the hash of the library; for example, the SHA-256 hash or other hash of version "1.2.3" of the "foo.bar.lib" library.

[0070] In other examples, a combined name and version identifier for the library can be provided. For instance, the combined name and version identifier can be formed by appending an underscore and the version to the library name. As a specific example, the "uses-static-library" tag in the example above, which includes the SHA-256 hash, can be modified to use the combined name and version number field "name_version", which specifies the combined name and version identifier library "foo.bar.lib" and version "1.2.3": <uses-static-library> name_version="foo.bar.lib_1.2.3" certDigest="6C:EC:C5:0E:34:AE:31:BF:B5:67:89:86:D6:D6:D3:73:6C:57:1D:ED:2F…"> In other examples, different naming schemes can be used to combine name and version information to form a combined name and version identifier for the library; for example, a different separator than underscores can be used, and the version can precede the library name in the combined identifier, etc.

[0071] Other representations of the name, version, hash, and / or information about the digital certificate associated with the library are also possible. Furthermore, other tags may have different information than the "static-library" tag described above when declaring a static library and / or may have different information than the "uses-static-library" tag described above when declaring the use of a static library.

[0072] Even with the correct name and version number, using a signing certificate claim and / or hash can reduce the likelihood of using incorrect and / or malicious versions of the library. Furthermore, using a signing certificate claim and / or hash allows for different sub-versions of the library, where sub-versions can be customized for specific devices; for example, optimized for specific screen sizes, processors, and / or other device components and / or features.

[0073] Application information 126 may include data about software application 122 that may not be specified by shared library information 124. For example, application information 126 may include data such as the name of software application 122, the version of software application 122, recent changes / bug fixes of software application 122, information about building software application 122, end-user documentation, and other possible data. In some examples, shared library information 124 and application information 126 may be combined; for example, application information 126 may include shared library information 124.

[0074] In some examples, software application 122 is associated with one or more "splitters" or additional functionalities of software application 120, which can be installed incrementally and separately from the installation of software application 122. In these examples, an application package similar to application package 120 can be generated for the split of software application 122, wherein shared library information 124 and / or application information 126 indicate that a split of software application 122 is being installed. In some of these examples, the shared library information 124 used for the split of software application 122 can add new libraries as dependencies, but cannot change the previously declared dependencies of software application 122. More specifically, suppose the installed software application 122 has a dependency on the shared library SL_PRESPLIT version V_PRESPLIT, and the split of software application 122, APP120_SPLIT, is to be installed. If shared library information 124 associated with APP120_SPLIT changes its dependency on shared library SL_PRESPLIT version V_PRESPLIT to, for example, a dependency on shared library SL_PRESPLIT version V_PRESPLIT+1, then shared library information 124 can be rejected. However, in these examples, shared library information 124 associated with APP120_SPLIT, which declares a new dependency on shared library SL_SPLIT1 version V_SPLIT2, will not be rejected.

[0075] Figure 2 Workflow 200 according to an example embodiment is illustrated. Workflow 200 illustrates example actions involved in providing complete software packages (FSPs) and shared software packages (SSPs) to computing devices 240 using an application store server 100. Workflow 200 begins at box 250, where one or more library development computing devices 210 build / generate a library package (LSP) with a library SL1. In workflow 200, library SL1 is a versioned software library with version number V23.2. The library development computing device 210 may upload the library package to the application store server 100, which may store the package in the repository at box 264.

[0076] Workflow 200 can continue with one or more application development computing devices 220 building / generating complete software packages (FSPs) and stripped software packages (SSPs), each of which includes an executable file for application App123. At box 252, application development computing device 220 can build the complete software package, which includes the complete executable file for App123. At box 260, application development computing device 220 can upload the complete software package to application store server 100, whereby application store server 100 can store the complete software package.

[0077] Since the complete executable of App123 built at box 252 includes any libraries that App123 depends on, the complete software package built at box 252 does not include shared library information. In other workflows, the aforementioned software upload utility may be executed by application development computing device 220 and / or app store server 100 to attempt to generate a stripped-down package, which takes the complete software package uploaded at block 260 as input.

[0078] At box 254, application development computing device 220 can build a stripped software package, which includes a stripped executable for App 123 and shared library information for the libraries that App 123 depends on. At box 262, application development computing device 220 can upload the stripped software package to app store server 100, whereby app store server 100 can store the complete software package.

[0079] In workflow 200, the shared library information constructed at box 254 is versioned shared library information. For example, if App123 depends on version V23.2 of library SL1 (i.e., the library constructed at box 250), the shared library information constructed at box 254 can specify that App123 uses version V23.2 of shared library SL1. In some workflows, the aforementioned software upload utility can be executed by application development computing device 220 and / or app store server 100 to verify that any libraries listed in the versioned shared library information stripped from the software package are eligible for sharing; that is, a specific version of a specified library in the versioned shared library information is indeed available for sharing.

[0080] After completing blocks 260, 262, and 264, app store server 100 stores at least the complete and stripped packages of App123, as well as the library package for library SL1 version V23.2. In workflow 200, App123 depends on only one library—library SL1 version V23.2—which is available from app store server 100 and therefore eligible for sharing. In other workflows, other applications may depend on zero or more libraries, which may differ from library SL1 version V23.2.

[0081] Workflow 200 continues to communicate with app store server 100 and one or more computing devices 230 to download the full and stripped software package of App 123; that is, the full and stripped software package previously uploaded in boxes 260 and 262. The computing device 230 downloading the full software package of App 123 during workflow 200 can execute the processes in boxes 270 and 272. In box 270, the computing device downloads the full software package of App 123 from app store server 100. In box 272, after downloading the full software package of App 123, the computing device installs App 123 using the downloaded full software package.

[0082] During workflow 200, the computing device 230 downloading the stripped software package of App 123 can execute the processes in blocks 280, 282, 284, and 286. In block 280, the computing device downloads the stripped software package of App 123 from the app store server 100. In block 282, the computing device and / or the app store server 100 can determine whether the shared libraries listed in the shared library information of the stripped software package are stored on the computing device. For example, the computing device and / or the app store server 100 can execute one or more of the queries described above to determine whether the computing device stores one or more versions of one or more shared libraries. If these queries indicate that all versions of the shared libraries listed in the shared library information are stored on the computing device, the process in block 282 can be completed. Otherwise, for each version of each shared library that is not stored on the computing device, the computing device and the app store server 100 can communicate to download the version of the shared library to the computing device.

[0083] In box 284, if any shared libraries were downloaded in box 282, those downloaded shared libraries can be installed on the computing device. In workflow 200, the computing device already had a copy of shared library SL1 version 23.2 installed before downloading the stripped package, so the shared library was not installed in box 284. In the related workflow, a copy of the library package uploaded in box 264 can be downloaded from the app store server in box 282 and installed in box 284. In box 286, the computing device can use the stripped package to install App123. After box 286 is completed, workflow 200 can be completed.

[0084] Figure 3A and 3BScenario 300, according to an example embodiment, illustrates the creation and installation of software applications using software packages and shared repositories. In scenario 300, one or more application computing development devices 220 create software packages for three applications A1, A2, and A3 and upload the packages to one or more app store servers 100. A1 depends on two libraries: library L1 version V1 and library L2 version V1.2. A2 depends on one library: library L1 version V1.1. And A3 depends on one library—library L2 version V1.3.2. In scenario 300, version V1 of library L1 and versions V1.2 and V1.3.2 of library L2 are eligible to be shared, while version V1.1 of library L1 is not eligible to be shared. Therefore, the stripped software packages can be used for subsequent downloads of A1 and A3, but not for A2.

[0085] Scenario 300 continues with computing device 302, including app store client 304, requesting to download applications A1, A2, and A3 from app store server 100. At the start of these requests, computing device 302 supports the use of shared libraries and has library L1 version V1 and library L2 version V1.2 installed, but library L2 version V1.3.2 not installed. In scenario 300, app store client 304 performs the aforementioned functions of the software download utility, as discussed in detail below. In other scenarios, some or all of the functions described herein as part of app store client 304 may be provided by app store server 100.

[0086] More generally, the computing device 302's support for the use of shared libraries includes the computing device 302 being configured to store multiple versions of a particular shared library identified by an identifier and a version, wherein each of the multiple versions of the particular shared library shares a common name / identifier, and wherein each of the multiple versions of the particular software library has a different version / version number. For example, the computing device 302 may store multiple versions with different version numbers for library L1, library L2, and / or one or more other named libraries; for example, two versions of repository L3—one with version number "V3.1" and the other with version number "V4.0". In other examples, the computing device 302 may store up to a maximum number of different software libraries, wherein each different software library is identified by both its name / identifier and version / version number; for example, a maximum of 5, 10, 12, or some other number of versions of all the named libraries stored thereon. In some examples, the computing device 302 may allocate a maximum amount of storage (e.g., 10 megabytes, 100 megabytes, 10 gigabytes) to store shared libraries. Other examples relating to storing multiple shared libraries are also possible.

[0087] In this context, computing device 302 and app store client 304 download and install: the stripped package of A1, the full package of A2 and the library package of library L2 version V1.3.2, and the stripped package of A3.

[0088] Subsequently, computing device 302 determines the amount of data storage to be released; and as part of releasing the data storage, it determines that shared libraries need to be cleaned up. For example, computing device 302 may determine that data storage needs to be released, including cleaning up shared libraries, because: the maximum number of shared libraries stored, the maximum amount of data storage used to store shared libraries, periodic (e.g., hourly, weekly, daily) or on-demand audits of data storage indicate that shared libraries need to be cleaned up, perhaps because the amount of free data storage available to computing device 302 is relatively low, the age of the shared libraries, and / or other reasons. Thus, computing device 302 may then attempt to clean up the shared libraries.

[0089] The age of a shared library can be: the amount of time associated with the existence of the shared library; the amount of time since the shared library was created; the amount of time since the shared library was stored on the computing device; or some other amount of time. Shared libraries can then be cleaned up based on their respective ages. For example, after computing device 302 determines the age of shared library SL_OLD version V_OLD and determines that the age of shared library SL_OLD version V_OLD exceeds a threshold age (e.g., 6 months, 1 year, 2 years, etc.), computing device 302 can determine whether the reference count of shared library SL_OLD version V_OLD is greater than zero. If the reference count of shared library SL_OLD version V_OLD is greater than zero, computing device 302 can determine that application A_OLD depends on shared library SL_OLD version V_OLD, and can, for example, replace the stripped executable of A_OLD that depends on shared library SL_OLD version V_OLD with a full executable containing a copy of shared library SL_OLD version V_OLD by downloading the full executable of A_OLD. Then, after replacing the stripped executable of A_OLD with the corresponding full executable, computing device 302 can release the data storage on the computing device used for the shared library SL_OLD version V_OLD.

[0090] During cleanup, the number of applications using each of Library L1 version V1 and Library L2 version V1.2, or the reference count of each of Library L1 version V1 and Library L2 version V1.2, exceeds a threshold, but the number of applications using Library L2 version V1.3.2 / the reference count of Library L2 version V1.3.2 does not exceed the threshold. Thus, Library L2 version V1.3.2 is cleaned up by installing the full executable file of application A3 (which depends on Library L2 version V1.3.2), and then deleting both the previously installed stripped executable file and a copy of Library L2 version V1.3.2 from the storage of computing device 302. After the cleanup of Library L2 version V1.3.2 is complete, scenario 300 can end.

[0091] Figure 3A Scenario 300 illustrates that application computing development device 220 can begin generating and sending upload message 310 to application store server 100. Upload message 310 includes two packages for application A1—a full package and a stripped package. The full package includes the complete executable file of application A1. The stripped package includes the stripped executable file of application A1 and shared library information about two shared libraries (SLs) that application A1 depends on: "L1, V1" and "L2, V1.2".

[0092] In scenario 300, app store server 100 executes an upload software utility to process upload message 310. The upload software utility verifies that the two shared libraries listed in the shared library information—library L1 version V1 and library L2 version V1.2—are eligible to be shared, and then stores the received full and stripped packages. At this point, both the full and stripped packages for application A1 are available for download from app store server 100.

[0093] Then, the application computing development device 220 generates an upload message 312 and sends it to the application store server 100. The upload message 312 includes two packages for application A2—a full package and a stripped package. The full package includes the complete executable file for application A2. The stripped package includes the stripped executable file for application A2 and information about the shared library "L1, V.1.1" that application A2 depends on.

[0094] In scenario 300, the app store server 100 executes an upload software utility to process upload message 312, which determines that version V1.1 of library L1 specified in the shared library information is not eligible for sharing. In response to determining that version V1.1 of library L1 is unsuitable for sharing, the app store server 100 generates and sends an unqualified shared library message 314 to notify the application computing development device 220 of the unqualified shared library. The upload software utility then rejects the package and stores the received complete package. At this point, the complete package of application A2 can be downloaded from the app store server 100.

[0095] In other scenarios, the upload software utility and / or other components of the application store server 100 may silently reject the stripped package due to unqualified shared libraries; that is, in these other scenarios, the unqualified shared library message 314 may not be sent. In some other scenarios, the application computing development device 220 may generate and send one or more additional upload messages with different shared library information that only lists qualified shared libraries; for example, a version of the stripped package upload message 312 that includes shared library information listing dependencies on version V1 of qualified shared library L1. The additional upload message may or may not have a complete package with the stripped package accompanied by different shared library information.

[0096] In other scenarios, the upload software utility and / or other components of the app store server 100 can determine that even if library L1 version V1.1 is not currently eligible for sharing, library L1 version V1.1 should be made eligible for sharing in response to upload message 312 and / or other upload messages that include a list of shared library information listing library L1 version V1.1. For example, if the app store server 100 receives at least a threshold number of references to a specific version of a particular library (e.g., 4, 10, 20, 100, 15000, etc.), and if the app store server 100 stores a copy of the library package for a specific version of a particular library, then the app store server 100 can determine that the specific version of a particular library is an eligible shared library.

[0097] Then, the application computing development device 220 generates an upload message 316 and sends it to the application store server 100. Upload message 316 includes the full package and the stripped package of application A3. The full package includes the complete executable file of application A3. The stripped package includes the stripped executable file of application A3 and shared library information about the shared library "L2, V.1.3.2" that application A3 depends on. In scenario 300, the application store server 100 executes an upload software utility to process upload message 316. The upload software utility verifies whether version V1.3.2 of library L2 is eligible for sharing and then stores the received full and stripped packages. At this point, both the full and stripped packages of application A3 are available for download from the application store server 100.

[0098] Scenario 300 continues with computing device 302 generating a GetApp message 320 and sending it to application store client 304, requesting a copy of application A1. Application store client 304, which includes software executing on computing device 302, receives GetApp message 320 and sends GetApp message 322 to application store server 100, requesting a copy of application A1 and a "SLInfo" indication for requesting shared library information for application A1. Through the "SLInfo" indication, computing device 302 signals support for the shared libraries of application A1. In other cases, other flags indicating support for or lack thereof in the shared libraries may be used; for example, an indication of whether computing device 302 is using or the version of the operating system that supports or does not support the shared libraries.

[0099] Upon receiving the GetApp message 322, the app store server 100 can generate an SLInfo message 324 and send it to the app store client 304. The SLInfo message 324 provides the app store client 304 with versioned shared library information about app A1, and thus provides the computing device 302 with versioned shared library information about app A1. Specifically, the SLInfo message 324 indicates that app A1 depends on library "L1" version "V1" and library "L2" version "V1.2".

[0100] Upon receiving the SLInfo message 324, the app store client 304 can obtain information on behalf of the app store server 100 about which shared libraries are stored on the computing device 302. To obtain this information, the app store client 304 generates and sends the SLQuery message 326 to other components of the computing device 302; for example, library management software determines whether the computing device 302 is a copy of library "L1" version "V1" because application A1 depends on library L1 version V1, as indicated above in the context of the SLInfo message 324.

[0101] Computing device 302 can receive an SLQuery message 326, which includes a queried library identifier "L1" and a queried library version "V1". Then, computing device 302 can determine whether it stores a copy of a version "V1" of library "L1" identified by the stored library identifier and the stored version "V1"; for example, the stored identifier and / or the stored version could be part or all of a unique name of the stored library determined using the unique name generation techniques discussed above and / or other techniques in the shared library information stored by computing device 302. Then, computing device 302 can match the queried library version "V1" with the stored version "V1" of library "L1". For example, computing device 302 can match the queried library version "V1" with the stored version "V1" of library "L1" based on dependency types such as exact dependency type, minimal dependency type, and template dependency type discussed above.

[0102] As described above, exact dependency type matching involves matching the queried library identifier and version exactly with the corresponding stored library identifier and version; minimal dependency type matching involves matching the queried library identifier with the stored library identifier and matching the queried library version, provided the stored library version is greater than or equal to the queried library version; template dependency type matching involves matching the queried library identifier with the stored library identifier and matching the queried library version, provided the stored library version matches the templated queried library version. Other matching techniques are also possible.

[0103] After matching the queried library version with the stored version, computing device 302 can determine that it does indeed store a copy of library "L1" version "V1". Having determined that it does indeed store a copy of library "L1" version "V1", computing device 302 can respond to SLQuery message 326 with a response indicating that it does indeed store a copy of the queried software library.

[0104] In scenario 300, computing device 302 confirms that a copy of library L1 version V1 is stored, and subsequently generates and sends SLQueryResp message 328 with an "OK" indication to notify app store client 304 that computing device 302 has indeed stored a copy of library L1 version V1.

[0105] The app store client 304 can generate an SLQuery message 330 and send it to the computing device 302 to determine whether the computing device 302 stores a copy of version "V1.2" of library "L2", since application A1 also depends on version V1.2 of library L2, as indicated above in the context of SLInfo message 324. In scenario 300, the computing device 302 can use the techniques discussed above in the context of SLQuery message 326 to determine that the computing device 302 does indeed store a copy of version V1.2 of library L2. The computing device 302 then generates and sends an SLQueryResp message 332 with an "OK" indication to notify the app store client 304 that the computing device 302 does indeed store a copy of version V1.2 of library L2.

[0106] Upon receiving the SLQueryResp message 332, the app store client 304 can generate and send a GetApp message 334 to convey a request for app A1 with a "SL OK" indication. The "SL OK" indication notifies the app store server 100 that the computing device 302 can utilize the stripped executable that depends on shared libraries, and that copies of all shared libraries that app A1 depends on have been stored. The app store server 100 can then generate and send a StrippedPkg message 336, which includes a copy of the stripped package containing the stripped executable for app A1.

[0107] At box 338, computing device 302 and app store client 304 install application A1 from the stripped package received via StrippedPkg message 330. Installing application A1 involves installing the stripped executable of A1 received via StrippedPkg message 330. In other scenarios, app store client 304 does not involve installing packages on computing device 302.

[0108] Then, computing device 302 generates GetApp message 340 and sends it to app store client 304, requesting a copy of app A2. App store client 304 receives GetApp message 340 and sends GetApp message 342 to app store server 100, requesting a copy of app A2 and a "SLInfo" instruction for requesting shared library information of app A2.

[0109] In scenario 300, due to the unqualified libraries discussed above in the context of messages 312 and 314, only the complete application package is available for application A2. Therefore, the application store server 100 generates and sends a FullPkg message 344 including a copy of the complete package containing the complete executable file of application A2. At box 346, computing device 302 and application store client 304 install application A2 from the complete package. Installing application A2 involves installing the complete executable file of A2 received via FullPkg message 344.

[0110] Then, computing device 302 generates GetApp message 350 and sends it to app store client 304, requesting a copy of app A3. App store client 304 receives GetApp message 350 and sends GetApp message 352 to app store server 100, requesting a copy of app A3 and a "SLInfo" instruction for requesting shared library information for app A3.

[0111] After receiving the GetApp message 352, the app store server 100 can generate an SLInfo message 354 and send it to the app store client 304. The SLInfo message 354 can provide the app store client 304 and the computing device 302 with versioned shared library information about the application A3. Specifically, the SLInfo message 354 indicates that the application A3 depends on library "L2" version "V1.3.2".

[0112] Upon receiving the SLInfo message 354, the app store client 304 can obtain information on behalf of the app store server 100 about which shared libraries are stored on the computing device 302. To obtain this information, the app store client 304 generates and sends the SLQuery message 356 to other components of the computing device 302, such as library management software used to determine whether the computing device 302 stores a copy of library "L2" version "V1.3.2", because application A3 depends on library L2 version V1.3.2, as described above in the context of the SLInfo message 354.

[0113] In scenario 300, computing device 302 can use the techniques discussed above in the context of SLQuery message 326 to determine that computing device 302 does not store a copy of repository L2 version V1.3.2. Computing device 302 then generates and sends SLQueryResp message 358 with a "No" indication to notify app store client 304 that computing device 302 does not store a copy of repository L2 version V1.3.2. Thus, SLQueryResp message 358 can act as a request to app store client 304 to locate a copy of the lost library L2 version V1.3.2 based on the name / identifier "L2" and version number "V.1.3.2".

[0114] In response to SLQueryResp message 358, app store client 304 can generate GetSL message 360 ​​and send it to app store server 100 to request the library package for version 1.3.2 of library L2. In response to GetSL message 360, app store server 100 can send LibPkg message 362 containing a copy of the library package for version 1.3.2 of library L2 to app store client 304.

[0115] After receiving the LibPkg message 362, the application store client 304 can determine that the computing device 302 has copies of all shared libraries used by application A3. Then, the application store client 304 can generate and send a GetApp message 364 to convey a request for application A3 with a “SL OK” indication. The “SL OK” indication informs the application store server 100 that the computing device 302 can utilize the stripped executable that depends on the shared libraries, and that copies of all shared libraries that application A3 depends on have been stored. Then, the application store server 100 can generate and send a StrippedPkg message 366, which includes a copy of the stripped package containing the stripped executable of application A3.

[0116] Go to Figure 3B Upon receiving LibPkg message 362 and StrippedPkg message 366, computing device 302 and application store client 304 can execute the process in box 368. In box 368, computing device 302 and application store client 304 install library L2 version V1.3.2 from the library package received via LibPkg message 362 and application A3 from the stripped package received via StrippedPkg message 366.

[0117] LibPkg message 362 can be seen as a response to the request embodied in SLQueryResp message 358 for locating a copy of the missing library L2 version V1.3.2, and therefore the application store client 304 has successfully located the missing library L2 version V1.3.2 on the computing device 302. By installing the previously missing library L2 version V1.3.2 received via LibPkg message 362, the computing device 302 can store the previously missing library L2 version V1.3.2. Installing application A3 involves installing the stripped executable of A3 received via StrippedPkg message 366.

[0118] At block 370, computing device 302 executes each of applications A1, A2, and A3 at least once. For example, executing application A1 may involve loading the executable file of A1 and any shared libraries that A1 depends on into the data storage (i.e., RAM and / or cache memory) of computing device 302. In this case, loading the executable file of A1 and the shared libraries that A1 depends on may include loading the stripped executable file of A1 mounted at block 332 and loading shared libraries L1 version V1.1 and L2 version V1.2, wherein the two shared libraries may be identified by their respective names / identifiers “L1” and “L2” and their respective versions “V1.1” and “V1.2”. In some examples, library L1 version V1.1 and / or library L2 version V1.2 may have already been loaded into the data storage; in these examples, the stripped executable file of A1 may reference one or more libraries that have already been loaded, and the reloading of one or more loaded libraries may be omitted.

[0119] Then, after loading the executable file of A1 and the shared libraries that A1 depends on, the computing device 302 can execute the loaded software executable file to enable the computing device to perform one or more functions of application A1, wherein at least one of these functions is performed using software stored in library L1 version V1.1 and / or library L2 version V1.2. Similar techniques can be used to execute application A2 or application A3; for application A2, which has a complete executable file, the techniques related to loading shared libraries can be omitted.

[0120] At box 380, computing device 302 determines that shared library storage needs to be cleaned up. That is, computing device 302 continues to attempt to reduce the amount of storage used by shared libraries stored on the computing device. To clean up the shared library storage, computing device 302 may determine the reference count for each version of each shared library. The reference count for a specific version of a particular shared library may be the number of applications that depend on a specific version of that particular shared library. For example, the reference count may be determined as discussed above in the context of library management software.

[0121] Then, if the reference count of a specific version of a specific shared library is less than the threshold reference count, that specific version of the specific shared library can be uninstalled. Furthermore, any stripped executables that depend on the specific version of the specific shared library now being uninstalled can be replaced by the corresponding full executable.

[0122] At box 382, ​​computing device 302 determines that the reference count of shared library L1 version V1 or the number of applications using shared library L1 version V1 exceeds a threshold reference count. In scenario 300, the threshold reference count is set to 2; in other scenarios, different threshold reference count values ​​can be used; for example, 1, 3, 4, 5, 10. Therefore, shared library L1 version V1 is unaffected by this cleanup.

[0123] At box 384, computing device 302 determines that the reference count of shared library L2 version V1.2 exceeds the threshold reference count. Therefore, shared library L2 version V1.2 is not affected by this cleanup.

[0124] At box 386, computing device 302 determines that the reference count of shared library L2 version V1.3.2 is less than the threshold reference count. In scenario 300, only application A3 depends on shared library L2 version V1.3.2, therefore its corresponding reference count is 1, which is less than the threshold reference count of 2. Therefore, shared library L2 version V1.3.2 is an object to be cleaned up; that is, shared library L2 version V1.3.2 can be uninstalled, and any stripped-down executables that depend on shared library L2 version V1.3.2 can be replaced with the corresponding full executables.

[0125] Thus, the stripped executable file of application A3 installed at box 368 can be replaced by the corresponding full executable file. To obtain the full executable file of application A3, computing device 302 generates a GetApp message 388 and sends it to application store client 304 to request delivery of application "A3". Application store client 304 transmits GetApp message 388 as GetApp message 390 to application store server 100 to request delivery of application "A3".

[0126] GetApp messages 388 and 390 include the instruction "SL NO" to notify the app store client 304 and the app store server 100, respectively, that shared libraries are not supported for app A3; thus, GetApp messages 388 and 390 effectively request the delivery of the full executable file for app A3. Other techniques for requesting the full executable file are also possible.

[0127] In response to GetApp message 390, app store server 100 can use the “A3” and “SL NO” indications to determine that the complete package of app A3 has been requested. Then, app store server 100 generates FullPkg message 392 with a copy of the complete package containing the complete executable of app A3 and sends it to app store client 304.

[0128] At box 394, computing device 302 and app store client 304 continue cleaning up library L2 version V1.3.2 by uninstalling the stripped executable of previously installed application A3. At box 396, computing device 302 and app store client 304 uninstall the previously installed shared library L2 version V1.3.2. After block 396 has been completed, at least two shared libraries—library L1 version V1 and library L2 version V1.2—are still installed on computing device 100. Scenario 300 can be completed after box 396 is completed. In other scenarios, app store client 304 does not involve the uninstallation of executables, libraries, and / or packages.

[0129] In box 398, computing device 302 and application store client 304 install application A3 from the complete software package received via FullPkg message 392. Installing application A3 involves installing the complete executable file of A3 received via FullPkg message 392. In some scenarios, the execution order of boxes 394, 396, and 398 may differ from the execution order of the three boxes used during scenario 300.

[0130] Example Data Network

[0131] Figure 4 A distributed computing architecture 400 with server devices 408 and 410 according to an example embodiment is depicted. The server devices 408 and 410 are configured to communicate with programmable devices 404a, 404b, 404c, 404d, and 404e via a network 406. The network 406 may correspond to a LAN, a wide area network (WAN), a corporate intranet, the public internet, or any other type of network configured to provide a communication path between networked computing devices. The network 406 may also correspond to one or more combinations of LANs, WANs, corporate intranets, and / or the public internet.

[0132] although Figure 4Only five programmable devices are shown, but a distributed application architecture can serve dozens, hundreds, or thousands of programmable devices. Furthermore, programmable devices 404a, 404b, 404c, 404d, 404e (or any additional programmable devices) can be any type of computing device, such as ordinary laptops, desktop computers, wearable computing devices, mobile computing devices, head-mounted displays (HMDs), network terminals, and wireless communication devices (e.g., smartphones and / or cellular phones). In some embodiments, represented, for example by programmable devices 404a, 404b, and 404c, the programmable devices can be directly connected to network 406. In other embodiments, represented, for example by programmable devices 404d and 404e, the programmable devices can be indirectly connected to network 406 through an associated computing device such as programmable device 404c. In this example, programmable device 404c can act as an associated computing device to transmit electronic communications between programmable devices 404d and 404e and network 406. Figure 4 In other embodiments not shown, the programmable device may be directly or indirectly connected to network 406.

[0133] Server devices 408 and 410 can be configured to perform one or more services requested by programmable devices 404a-404e. For example, server devices 408 and / or 410 can provide content to programmable devices 404a-404e. Content may include, but is not limited to, web pages, hypertext, scripts, binary data such as compiled software, images, audio, and / or video. Content may include compressed and / or uncompressed content. Content may be encrypted and / or unencrypted. Other types of content are also possible.

[0134] As another example, server devices 408 and / or 410 may provide programmable devices 404a-404e with access to software for database, search, computing, graphics, audio, video, World Wide Web / Internet utilization and / or other functions. Many other examples of server devices are also possible.

[0135] Computing device architecture

[0136] Figure 5A This is a functional block diagram of a computing device 500 according to an example embodiment. Specifically, Figure 5AThe computing device 500 shown may be configured to perform at least one of the following or related functions: the software described herein, application store server 100, library package 110, application package 120, workflow 200, library development computing device 210, application development computing device 220, computing devices 230, 302, scenario 300, application store client 304, programmable devices 404a, 404b, 404c, 404d, 404e, network 406, server devices 408, 410, and method 600.

[0137] The computing device 500 may include a user interface module 501, a network communication interface module 502, one or more processors 503, a data storage 504, and one or more sensors 520, all of which can be linked together via a system bus, network, or other connection mechanism 505.

[0138] User interface module 501 can be used to send data to and / or receive data from external user input / output devices. For example, user interface module 501 can be configured to send and / or receive data from user input devices, such as keyboards, keypads, touchscreens, computer mice, trackballs, joysticks, cameras, voice recognition modules, and / or other similar devices. User interface module 501 can also be configured to provide output to user display devices, such as one or more cathode ray tubes (CRTs), liquid crystal displays, light-emitting diodes (LEDs), displays using digital light processing (DLP) technology, printers, light bulbs, and / or other similar devices, now known or developed in the future. User interface module 501 can also be configured to generate audible outputs, such as speakers, speaker jacks, audio output ports, audio output devices, headphones, and / or other similar devices. User interface module 501 can also be configured with one or more tactile devices that can generate tactile outputs, such as vibrations and / or other outputs detectable by touch and / or physical contact with computing device 500. In some embodiments, the user interface module 501 may be used to provide a graphical user interface for utilizing the computing device 500.

[0139] The network communication interface module 502 may include one or more wireless interfaces 507 and / or one or more wired interfaces 508, which can be configured to communicate via a network. The wireless interface 507 may include one or more wireless transmitters, receivers, and / or transceivers, such as Bluetooth. TM Transceiver, Zigbee® transceiver, Wi-Fi TM transceiver, WiMAX TMThe transceiver and / or other similar types of wireless transceivers that can be configured to communicate over a wireless network. The wired interface 508 may include one or more wired transmitters, receivers, and / or transceivers, such as Ethernet transceivers, Universal Serial Bus (USB) transceivers, or similar transceivers that can be configured to communicate over twisted-pair, coaxial, fiber optic links, or similar physical connections to a wired network.

[0140] In some embodiments, the network communication interface module 502 can be configured to provide reliable, secure, and / or authenticated communication. For each communication described herein, information for ensuring reliable communication (i.e., guaranteed message delivery) may be provided, possibly as part of a message header and / or footer (e.g., packet / message sequence information, encapsulation headers and / or footers, size / time information, and transmission verification information such as CRC and / or parity values). One or more encryption protocols and / or algorithms, such as, but not limited to, Data Encryption Standard (DES), Advanced Encryption Standard (AES), Rivest-Shamir-Adelman (RSA) algorithm, Diffie-Hellman algorithm, Secure Sockets Protocols such as Secure Sockets Layer (SSL) or Transport Layer Security (TLS), and / or Digital Signature Algorithm (DSA), can be used to secure (e.g., be encoded or encrypted) and / or decrypt / decode the communication. Other encryption protocols and / or algorithms, besides those listed herein, can also be used to protect (and then decrypt / decode) the communication.

[0141] One or more processors 503 may include one or more general-purpose processors and / or one or more special-purpose processors (e.g., digital signal processors, graphics processing units, application-specific integrated circuits, etc.). One or more processors 503 may be configured to execute computer-readable program instructions 506 and / or other instructions as described herein, contained in data storage 504.

[0142] Data storage 504 may include one or more computer-readable storage media that can be read and / or accessed by at least one of one or more processors 503. The one or more computer-readable storage media may include volatile and / or non-volatile storage components, such as optical, magnetic, organic, or other storage or disk storage, which may be integrated wholly or partially with at least one of the one or more processors 503. In some embodiments, data storage 504 may be implemented using a single physical device (e.g., a single optical, magnetic, organic, or other storage or disk storage unit), while in other embodiments, two or more physical devices may be used to implement data storage 504.

[0143] Data storage 504 may include computer-readable program instructions 506 and possible additional data. In some embodiments, data storage 504 may additionally include storage required for performing at least some of the functions of the methods, scenarios, and techniques described herein and / or at least some of the functions of the devices and networks described herein.

[0144] In some embodiments, computing device 500 may include one or more sensors 520. Sensors 520 may be configured to measure conditions in the environment of computing device 500 and provide data about that environment. For example, sensors 520 may include one or more of the following: (i) identification sensors that identify other objects and / or devices, such as, but not limited to, radio frequency identification (RFID) readers, proximity sensors, one-dimensional barcode readers, two-dimensional barcode (e.g., quick response (QR) code) readers, and laser trackers, wherein the identification sensors may be configured to read identifiers such as RFID tags, barcodes, QR codes, and / or other devices and / or objects configured to be read and provide at least identification information; (ii) position sensors for measuring the position and / or movement of computing device 500, such as, but not limited to, gyroscopes, accelerometers, Doppler sensors, global positioning system (GPS) devices, sonar sensors, radar devices, and laser positioning systems. (iii) Motion sensors and a compass; environmental sensors for acquiring data indicating the environment of computing device 500, such as, but not limited to, infrared sensors, optical sensors, light sensors, cameras, biosensors, capacitive sensors, touch sensors, temperature sensors, wireless sensors, radio sensors, motion sensors, microphones, sound sensors, ultrasonic sensors, and / or smoke sensors; (iv) force sensors for measuring one or more forces (e.g., inertial forces and / or G-forces) acting on computing device 500, such as, but not limited to, one or more sensors measuring forces in one or more dimensions, torque, ground forces, friction, and / or zero-torque point (ZMP) sensors that identify the ZMP and / or the location of the ZMP. Many other examples of sensors 520 are also possible.

[0145] Cloud-based servers

[0146] Figure 5BA network 514 is depicted for computing clusters 509a, 509b, 509c arranged as a cloud-based server system according to an example embodiment. Computing clusters 509a, 509b, 509c may be cloud-based devices that store program logic and / or data for cloud-based applications and / or services; for example, performing at least one of the following or related functions: the software described herein, application store server 100, library software package 110, application software package 120, workflow 200, library development computing device 210, application development computing device 220, computing devices 230, 302, scenario 300, application store client 304, programmable devices 404a, 404b, 404c, 404d, 404e, network 406, server devices 408, 410, and method 600.

[0147] In some embodiments, computing clusters 509a, 509b, and 509c may be single computing devices residing in a single computing center. In other embodiments, computing clusters 509a, 509b, and 509c may be multiple computing devices included in a single computing center, or even multiple computing devices located in multiple computing centers in different geographical locations. For example, Figure 5B Each computing cluster, 509a, 509b, and 509c, is depicted residing in different physical locations.

[0148] In some embodiments, the data and services at computing clusters 509a, 509b, and 509c may be encoded as computer-readable information stored in a non-transitory tangible computer-readable medium (or computer-readable storage medium) and accessible by other computing devices. In some embodiments, computing clusters 509a, 509b, and 509c may be stored on a single disk drive or other tangible storage medium, or may be implemented on multiple disk drives or other tangible storage media located in one or more different geographical locations.

[0149] Figure 5B A cloud-based server system according to an example embodiment is described. Figure 5BIn this document, the software, app store server, app store client, library development computing device, application development computing device, and / or the functionality of computing devices can be distributed among computing clusters 509a, 509b, and 509c. Computing cluster 509a may include one or more computing devices 500a, cluster storage array 510a, and cluster router 511a connected by a local cluster network 512a. Similarly, computing cluster 509b may include one or more computing devices 500b, cluster storage array 510b, and cluster router 511b connected by a local cluster network 512b. Likewise, computing cluster 509c may include one or more computing devices 500c, cluster storage array 510c, and cluster router 511c connected by a local cluster network 512c.

[0150] In some embodiments, each of computing clusters 509a, 509b, and 509c may have the same number of computing devices, the same number of cluster storage arrays, and the same number of cluster routers. However, in other embodiments, each computing cluster may have a different number of computing devices, a different number of cluster storage arrays, and a different number of cluster routers. The number of computing devices, cluster storage arrays, and cluster routers in each computing cluster may depend on the computing tasks allocated to each computing cluster.

[0151] In computing cluster 509a, for example, computing device 500a may be configured to perform various computing tasks of the software, app store server, app store client, library development computing device, application development computing device, and / or computing device described herein. In one embodiment, the various functions of the software, app store server, app store client, library development computing device, application development computing device, and / or computing device described herein may be distributed among one or more computing devices 500a, 500b, and 500c. Computing devices 500b and 500c in each computing cluster 509b and 509c may be configured similarly to computing device 500a in computing cluster 509a. Alternatively, in some embodiments, computing devices 500a, 500b, and 500c may be configured to perform different functions.

[0152] In some embodiments, computing tasks and stored data associated with the software, app store server, app store client, library development computing device, application development computing device and / or computing device described herein may be distributed on computing devices 500a, 500b, and 500c, at least in part, based on the processing requirements of the software, app store server, app store client, library development computing device, application development computing device and / or computing device described herein, the processing capabilities of computing devices 500a, 500b, and 500c, the latency of network links between computing devices in each computing cluster and between the computing clusters themselves, and / or other factors that may contribute to the overall system architecture’s cost, speed, fault tolerance, resilience, efficiency and / or other design goals.

[0153] The clustered storage arrays 510a, 510b, and 510c of computing clusters 509a, 509b, and 509c can be data storage arrays, including disk array controllers configured to manage read and write access to the hard disk drive groups. The disk array controllers, individually or together with their respective computing devices, can also be configured to manage backups or redundant copies of data stored in the clustered storage arrays to prevent disk drive or other clustered storage array failures and / or network failures that could prevent one or more computing devices from accessing one or more clustered storage arrays.

[0154] Similar to how the functionality of the software, app store server, app store client, library development computing device, application development computing device, and / or computing device described herein can be distributed across computing devices 500a, 500b, and 500c in computing clusters 509a, 509b, and 509c, various active and / or backup portions of these components can be distributed across clustered storage arrays 510a, 510b, and 510c. For example, some clustered storage arrays can be configured to store a portion of the data from the software, app store server, app store client, library development computing device, application development computing device, and / or computing device described herein, while other clustered storage arrays can store other portions of the data from the software, app store server, app store client, library development computing device, application development computing device, and / or computing device described herein. Furthermore, some clustered storage arrays can be configured to store backup versions of data stored in other clustered storage arrays.

[0155] Cluster routers 511a, 511b, and 511c in computing clusters 509a, 509b, and 509c may include network devices configured to provide internal and external communication for the computing clusters. For example, cluster router 511a in computing cluster 509a may include one or more Internet switching and routing devices configured to (i) provide local area network communication between computing device 500a and cluster storage array 510a via local cluster network 512a, and (ii) provide wide area network communication between computing cluster 509a and computing clusters 509b and 509c via wide area network connection 513a to network 406. Cluster routers 511b and 511c may include network devices similar to those in cluster router 511a, and cluster routers 511b and 511c may perform similar network functions for computing clusters 509b and 509b as those performed by cluster router 511a for computing cluster 509a.

[0156] In some embodiments, the configuration of cluster routers 511a, 511b, 511c may be based at least in part on the data communication requirements of computing devices and cluster storage arrays, the data communication capabilities of network devices in cluster routers 511a, 511b, 511c, the latency and throughput of local networks 512a, 512b, 512c, the latency, throughput, and cost of WAN links 513a, 513b, 513c, and / or other factors that may contribute to cost, speed, fault tolerance, resilience, efficiency, and / or other design criteria for a moderate system architecture.

[0157] Example operation method

[0158] Figure 6 This is a flowchart of method 600 according to an example embodiment. Method 600 can be performed by a computing device such as computing device 500. Method 600 may begin at block 610, wherein the computing device may receive versioned shared library information of at least a first software library used by a software application, wherein the versioned shared library information of the first software library may include the identifier of the first software library, such as the identifier of the first software library, as mentioned above. Figure 2-3B In the context discussed above, in some embodiments, at least the versioned shared library information of the first software library also includes information related to the hash of the first software library, such as those mentioned above. Figure 1 This is discussed in the context of [the topic].

[0159] At box 620, the computing device can determine whether the computing device stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information, for example, at least as mentioned above. Figure 2-3B This is discussed in the context of [the topic].

[0160] In some embodiments, the versioned shared library information of the first software library may further include the version of the first software library, and the first software library is also identified by the version of the first software library; that is, the computing device can determine whether the computing device stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information and the version of the first software library, for example, as mentioned above at least in Figure 2-3B This is discussed in the context of [the relevant context]. In specific embodiments of these embodiments, the versioned shared library information of the first software library may include a combined identifier specifying the name of the first software library and the version of the first software library, such as at least as described above. Figure 1 This is discussed in the context of [the topic].

[0161] In other embodiments, determining whether a computing device stores a copy of a first software library identified by an identifier and a version of the first software library may include: receiving a query regarding the storage of the software library, the query including a queried library identifier and a queried library version; determining whether the computing device stores a copy of the first software library identified by the stored identifier and the stored version of the first software library by at least matching the queried library version with a stored version of the first software library; and determining that the computing device does indeed store a copy of the first software library after matching the queried library version with a stored version of the first software library, such as at least the aforementioned... Figure 3A and 3B This is discussed in the context of [the previous discussion]. In certain embodiments of these embodiments, matching the queried library version with the stored version of the first software library may include an exact match between the queried library version and the stored version of the first software library, such as [as discussed above at least in [the previous discussion]]. Figure 3A and 3B This is discussed in the context of [the previous discussion]. In other specific embodiments of these embodiments, matching the requested library version with a stored version of the first software library may include determining whether the stored software library version is at least the version of the queried library, such as [as mentioned above]. Figure 3A and 3B This is discussed in the context of [the topic].

[0162] At box 630, the computing device may, based on whether the computing device stores a copy of the first software library, send a request for either a full executable file or a stripped executable file for the software application, wherein the full executable file includes the first software library, and wherein the stripped executable file does not include the first software library, as described above at least in Figure 2-3B This is discussed in the context of [the previous sentence].

[0163] At box 640, in response to the request, the computing device may receive a complete executable file or a stripped executable file for a software application, for use stored on the computing device, such as at least as previously stated. Figure 2-3B This is discussed in the context of [the previous sentence].

[0164] In some embodiments, receiving a full executable file or a stripped executable file includes receiving a stripped executable file; then, method 600 may further include: loading the stripped executable file and a first software library into a data storage of a computing device, wherein the first software library is identified using an identifier and a version of the first software library; after loading the stripped executable file and the first software library into the data storage, the computing device executes the loaded stripped executable file to cause the computing device to perform one or more functions, wherein at least one function of the one or more functions is performed using software stored in the first software library, such as the aforementioned at least in Figure 3A and 3B This is discussed in the context of [the previous discussion]. In certain embodiments of these embodiments, method 600 may further include: after determining that the computing device does not store a copy of the first software library, locating a copy of the first software library based on an identifier and a version of the first software library, and storing the located copy of the first software library on the computing device, such as [as discussed above at least in the previous discussion]. Figure 3A and 3B In the context discussed above, in more specific embodiments of these embodiments, locating a copy of the first software library includes: sending a request for a copy of the first software library, wherein the request includes an identifier of the first software library and a version of the first software library, and receiving a copy of the first software library at a computing device after sending the request, such as at least as previously discussed above. Figure 3A and 3B This is discussed in the context of [the previous sentence].

[0165] In other embodiments, the computing device may be configured to store multiple versions of a second software library identified by an identifier and a version, wherein each version of the multiple versions of the second software library shares a common identifier, and wherein each version of the multiple versions of the second software library is different, such as as mentioned above at least in Figure 1-3B This is discussed in the context of [the previous discussion]. In some of these embodiments, the computing device may be configured to store a specific number of versions of the second software library, such as those mentioned above at least in [the previous discussion]. Figure 3A and 3B This is discussed in the context of [the previous discussion]. In a further embodiment of these embodiments, the computing device may be configured to determine the moment when the application using the first version of the second software library is invoked, such as at least as previously discussed. Figure 3A and 3BThis is discussed in the context of [the previous discussion]. In a further embodiment of these embodiments, method 600 may also include: determining to release data storage on the computing device; after determining to release the data storage, the computing device determines whether the number of applications using the first version of the second software library is less than a threshold; and after determining that the number of applications using the first version of the second software library is less than the threshold, removing the first version of the second software library from the data storage on the computing device, for example, at least as described above. Figure 3A and 3B This is discussed in the context of [the previous sentence].

[0166] In a further embodiment of these embodiments, sending a request for one of the full executable file and the stripped executable file of the software application may include: the computing device determining whether the number of applications using the first version of the second software library is less than a threshold; and after determining that the number of applications using the first version of the second software library is less than the threshold, sending a request for the full executable file of the software application, as described above. In some other specific embodiments of these embodiments, sending a request for one of the full executable file and the stripped executable file of the software application may further include: after determining that the number of applications using the first version of the second software library is not less than a threshold, sending a request for the stripped executable file of the software application, as described above. In other further specific embodiments of these embodiments, the threshold number may be 1, as mentioned above at least in Figure 3A and 3B This is discussed in the context of [the previous sentence].

[0167] In some of these embodiments, method 600 may further include: determining to remove a first software executable file utilizing a first version of the second software library from the computing device; and after determining the removal of the first software, the computing device: removes the first software executable file and decrements the number of applications using the first version of the second software library, such as at least as described above. Figure 3A and 3B In the context discussed above, in other embodiments, method 600 may further include: receiving a first software package including a second software executable and first package information, the package information including first versioned shared library information, which includes an identifier of the second software library and a first version of a particular software library; storing the second software executable and the first package information on a computing device; and incrementing the number of applications using the first version of the second software library, such as those discussed above at least in [the context of the previous examples]. Figure 3A and 3B This is discussed in the context of [the previous sentence].

[0168] In other embodiments, each of the plurality of versions of the second software library may have an age; then, method 600 may further include: determining whether the age of a second version of the second software library exceeds a threshold age; and after determining that the age of the second version of the second software library exceeds the threshold age: determining a third software executable file that depends on the second version of the second software library; replacing the third software executable file with a fourth software executable file that includes the second version of the second software library; and after replacing the third software executable file, releasing data storage for the second version of the second software library on a computing device, such as at least as described above. Figure 3A and 3B This is discussed in the context of [the previous discussion]. In other embodiments, the computing device is also configured to generate a unique name for each of multiple versions of the second software library, as discussed above.

[0169] In certain embodiments of these examples, matching the queried library version with the storage version of the first software library may include ensuring that the queried library version exactly matches the storage version of the first software library, for example, as described above at least in... Figure 3A and 3B This is discussed in the context of [the previous discussion]. In other specific embodiments of these embodiments, matching the queried library version with a stored version of the first software library may include determining whether the stored software library version is at least the requested library version, such as [as mentioned above]. Figure 3A and 3B This is discussed in the context of [the topic].

[0170] In other embodiments, method 600 may further include: receiving at a computing device versioned shared library information of at least a fourth software library used by a second software application, wherein the versioned shared library information of the fourth software library includes an identifier and a version of the fourth software library, and wherein the second software application depends on the fourth software library and a fifth software library; after determining that the computing device stores a copy of the fourth software library identified by the identifier and version of the fourth software library in the versioned shared library information, sending from the computing device a request for stripping one of the executable files of the second software application, wherein the stripped executable file does not include the fourth software library; and in response to the request, receiving a partially complete executable file of the second software application stored on the computing device, wherein the partially complete executable file of the second software application does not include the fourth software library and includes a copy of the fifth software library, as described above.

[0171] Other example embodiments

[0172] The following terms are provided as a further description of this disclosure.

[0173] Clause 1 - A method comprising: receiving at a computing device versioned shared library information of a first software library used by at least a software application, wherein the versioned shared library information of the first software library includes an identifier of the first software library; determining whether the computing device stores a copy of the first software library identified by the identifier of the first software library in the versioned shared library information; based on whether the computing device stores the copy of the first software library, sending a request for one of a full executable file and a stripped executable file of the software application, wherein the full executable file includes the first software library, and wherein the stripped executable file does not include the first software library; and in response to the request, receiving either the full executable file or the stripped executable file of the software application for storage on the computing device.

[0174] The method of Clause 2-1, wherein the versioned shared library information of the first software library further includes the version of the first software library; and the first software library is further identified by the version of the first software library.

[0175] The method of Clause 3-2, wherein the versioned shared library information for the first software library includes a combined identifier specifying the name of the first software library and the version of the first software library.

[0176] The method of any one of Clauses 4-1-3, wherein receiving the complete executable or the stripped executable comprises: receiving the stripped executable, and wherein the method further comprises: loading the stripped executable and the first software library into the data storage of the computing device, wherein the first software library is identified using the identifier of the first software library and the version of the first software library; and, after loading the stripped executable and the first software library into the data storage, the computing device executes the loaded stripped executable to cause the computing device to perform one or more functions, wherein at least one of the one or more functions is performed using software stored in the first software library.

[0177] The method of any one of Clauses 5-1-4 further includes: after determining that the computing device does not store the copy of the first software library, locating the copy of the first software library based on the identifier of the first software library and the version of the first software library, and storing the located copy of the first software library on the computing device.

[0178] The method of Clauses 6-5, wherein locating the copy of the first software library comprises: sending a request for a copy of the first software library, wherein the request includes the identifier of the first software library and the version of the first software library, and, after sending the request, receiving the copy of the first software library at the computing device.

[0179] The method of any one of Clauses 7-1-6, wherein at least the versioned shared library information of the first software library also includes information related to the hash of the first software library.

[0180] The method of any one of Clauses 8-1-7, wherein the computing device is configured to store multiple versions of a second software library identified by an identifier and a version, wherein each of the multiple versions of the second software library shares a common identifier, and wherein each of the multiple versions of the second software library is different.

[0181] The method of Clauses 9-8, wherein the computing device is configured to store a specific number of versions of the second software library.

[0182] The method of Clauses 10-8 or 9, wherein the computing device is configured to determine a plurality of applications using a first version of the second software library.

[0183] The method of Clauses 11-10 further includes: determining to release data storage of the computing device; after determining to release data storage, the computing device determining whether the number of applications using the first version of the second software library is less than a threshold; and after determining that the number of applications using the first version of the second software library is less than the threshold, removing the first version of the second software library from the data storage of the computing device.

[0184] The method of Clause 12-10 or Clause 11, wherein sending the request for one of the full executable file and the stripped executable file of the software application comprises: the computing device determining whether the number of applications using the first version of the second software library is less than the threshold; and, after determining that the number of applications using the first version of the second software library is less than the threshold, sending the request for the full executable file of the software application.

[0185] The method of Clauses 13-12, wherein sending the request for one of the full executable file and the stripped executable file of the software application further includes: after determining that the number of applications using the first version of the second software library is not less than the threshold, sending the request for the stripped executable file of the software application.

[0186] The method of any one of Clauses 14-11-13, wherein the number of thresholds is 1.

[0187] Clause 15 - The method according to any one of Clauses 10-14 further includes: determining to remove a first software executable file utilizing the first version of the second software library from the computing device; and, after determining to remove the first software executable file, the computing device: removes the first software executable file and reduces the number of applications using the first version of the second software library.

[0188] Clause 16 - The method according to any one of Clauses 10-15 further includes: receiving a first software package including a second software executable and first package information, the package information including an identifier for the second software executable and first versioned shared library information of a first version of the particular software library; storing the second software executable and the first package information on the computing device; and incrementing the number of applications using the first version of the second software library.

[0189] The method of any one of Clauses 17-8-16, wherein each of the plurality of versions of the second software library has an age, and wherein the method further comprises: determining whether the age of a second version of the second software library exceeds a threshold age; and, after determining that the age of the second version of the second software library exceeds the threshold age: determining a third software executable file that depends on the second version of the second software library; replacing the third software executable file with a fourth software executable file that includes the second version of the second software library; and, after replacing the third software executable file, releasing data storage for the second version of the second software library on the computing device.

[0190] Clause 18 - The method according to any one of Clauses 8-17, wherein the computing device is further configured to generate a unique name for each of the plurality of versions of the second software library.

[0191] The method of any one of Clauses 19-1-18, wherein determining whether the computing device stores the copy of the first software library identified by the identifier of the first software library comprises: receiving a query regarding the storage of the software library, the query including a queried library identifier and a queried library version; determining whether the computing device stores the copy of the first software library identified by the storage identifier of the first software library and the storage version of the first software library by at least matching the queried library version with the storage version of the first software library; and determining that the computing device does indeed store the copy of the first software library after matching the queried library version with the storage version of the first software library.

[0192] The method of Clauses 20-19, wherein matching the queried library version with the stored version of the first software library includes: precisely matching the queried library version with the stored version of the first software library.

[0193] The method of Clauses 21-19 or 20, wherein matching the queried library version with the stored version of the first software library includes: determining whether the stored version of the software library is at least the queried library version.

[0194] Clause 22 - The method according to any one of Clauses 1-21 further comprises: receiving at the computing device versioned shared library information of at least a fourth software library used by a second software application, wherein the versioned shared library information of the fourth software library includes an identifier of the fourth software library and a version of the fourth software library, and wherein the second software application depends on the fourth software library and a fifth software library; after determining that the computing device stores a copy of the fourth software library identified by the identifier of the fourth software library and the version of the fourth software library in the versioned shared library information, sending from the computing device a request for stripping one of the executable files of the second software application, wherein the stripped executable file does not include the fourth software library; and, in response to the request, receiving a partially complete executable file for the second software application stored on the computing device, wherein the partially complete executable file of the second software application does not include the fourth software library and includes a copy of the fifth software library.

[0195] Clause 23 - A computing device comprising: one or more processors; and a data storage, including at least computer-executable instructions stored thereon, which, when executed by the one or more processors, cause the computing device to perform the functions of any one of Clauses 1-22.

[0196] Clause 24 - A computer-readable medium having instructions stored thereon, which, when executed by one or more processors of a computing device, cause the computing device to perform the functions of the methods comprising any one of Clauses 1-22.

[0197] Computer-readable media of Clauses 25-24, wherein the computer-readable media includes non-transitory computer-readable media.

[0198] Clause 26 - An apparatus comprising: a component for performing the method of any one of Clauses 1-22.

[0199] This disclosure is not limited to the specific embodiments described herein, which are intended to be illustrative of various aspects. Many modifications and variations can be made without departing from the spirit and scope of the invention, as will be apparent to those skilled in the art. In addition to those listed herein, functionally equivalent methods and apparatus within the scope of this disclosure will be apparent to those skilled in the art from the foregoing description. These modifications and variations are intended to fall within the scope of the appended claims.

[0200] The detailed description above, with reference to the accompanying drawings, illustrates various features and functions of the disclosed systems, devices, and methods. In the drawings, similar symbols generally identify similar components unless the context otherwise indicates. The illustrative embodiments described in the detailed description, drawings, and claims are not intended to be limiting. Other embodiments may be utilized, and other changes may be made, without departing from the spirit or scope of the subject matter set forth herein. It will be readily understood that aspects of this disclosure as generally described herein and shown in the drawings can be arranged, replaced, combined, separated, and designed in a variety of different configurations, all of which are expressly contemplated herein.

[0201] With respect to any or all ladder diagrams, scenarios, and flowcharts in the figures and as discussed herein, each block and / or communication may represent information processing and / or information transmission according to the exemplary embodiments. Alternative embodiments are included within the scope of these exemplary embodiments. In these alternative embodiments, for example, functions described as blocks, transmissions, communications, requests, responses, and / or messages may be performed in a different order than shown or discussed, including substantially simultaneously or in reverse order, depending on the functions involved. Furthermore, more or fewer blocks and / or functions may be used for any of the ladder diagrams, scenarios, and flowcharts discussed herein, and these ladder diagrams, scenarios, and flowcharts may be combined with each other in part or in whole.

[0202] A block representing information processing may correspond to a circuit that can be configured to perform a specific logical function of the method or technique described herein. Alternatively or additionally, a block representing information processing may correspond to a module, segment, or portion of program code (including associated data). The program code may include one or more instructions executable by a processor for implementing a specific logical function or action in the method or technique. The program code and / or associated data may be stored on any type of computer-readable medium, such as a storage device including a disk or hard disk drive or other storage media.

[0203] Computer-readable media may also include non-transitory computer-readable media, such as non-transitory computer-readable media that store data for short periods of time, such as register memory, processor cache, and random access memory (RAM). Computer-readable media may also include non-transitory computer-readable media that store program code and / or data for longer periods of time, such as secondary or persistent long-term memory, such as read-only memory (ROM), optical discs or magnetic disks, and compact read-only memory (CD-ROM). Computer-readable media may also be any other volatile or non-volatile storage system. Computer-readable media can be considered as computer-readable storage media, such as tangible storage devices.

[0204] Furthermore, a block representing one or more information transfers can correspond to information transfers between software and / or hardware modules within the same physical device. However, other information transfers can occur between software and / or hardware modules in different physical devices.

[0205] While various aspects and embodiments have been disclosed herein, other aspects and embodiments will be apparent to those skilled in the art. The various aspects and embodiments disclosed herein are for illustrative purposes only and are not restrictive; the true scope is indicated by the appended claims.

Claims

1. A computer-implemented method, comprising: At the first computing device, a request for an executable file for a software application stored on the second computing device is received from the second computing device. The first computing device determines that the software application uses a first version of the shared library; Before the software application is installed on the second computing device, the first computing device requests and receives an indication from the second computing device as to whether the second computing device has already stored a copy of the first version of the shared library; The first computing device determines, based on data indicating the stability of one or more versions of the shared library, whether the first version of the shared library is eligible to be shared among multiple software applications on the second computing device; The executable file of the software application is determined by the first computing device, wherein, when the indication is that the second computing device has stored a copy of the first version of the shared library and based on the determination that the first version of the shared library is eligible for sharing among the plurality of software applications on the second computing device, the executable file of the software application includes a stripped executable file, wherein the stripped executable file does not include the first version of the shared library, wherein, when the indication is that the second computing device has not stored a copy of the first version of the shared library or based on the determination that the first version of the shared library is not eligible for sharing among the plurality of software applications on the second computing device, the executable file of the software application includes a full executable file, and wherein the full executable file includes the first version of the shared library; and The executable file of the software application is transferred from the first computing device to the second computing device.

2. The computer-implemented method according to claim 1, wherein, Before installing the software application on the second computing device, requesting and receiving an indication as to whether the second computing device has already stored a copy of the first version of the shared library includes: determining that the second computing device has already stored the copy of the first version of the shared library, and wherein transferring the executable file for the software application includes: transferring the stripped executable file from the first computing device to the second computing device.

3. The computer-implemented method according to claim 1, wherein, Before installing the software application on the second computing device, requesting and receiving an indication as to whether the second computing device has already stored a copy of the first version of the shared library includes: determining that the second computing device has not yet stored the copy of the first version of the shared library, and wherein transferring the executable file for the software application includes: transferring the complete executable file from the first computing device to the second computing device.

4. The computer-implemented method according to claim 3, wherein, The first computing device includes versioned shared information of at least a first version of the shared library used by the software application, wherein the versioned shared information of the first version of the shared library includes an identifier of the shared library and a version identifier of the first version of the shared library, and wherein the first version of the shared library is identified by the identifier of the shared library and the version identifier of the first version of the shared library.

5. The computer-implemented method according to claim 4, further comprising: After determining that the second computing device has not yet stored a copy of the first version of the shared library: The first computing device locates a copy of the first version of the shared library based on the identifier of the shared library and the version identifier of the first version of the shared library; and A copy of the first version of the located shared library is transferred from the first computing device to the second computing device.

6. The computer-implemented method according to claim 1, wherein, The second computing device is configured to store multiple versions of a second shared library identified by an identifier and a version, wherein each of the multiple versions of the second shared library shares a common identifier, wherein each of the multiple versions of the second shared library is different from the other versions, and wherein the second computing device is configured to store a specific number of versions of the second shared library.

7. The computer-implemented method according to claim 1, wherein, Determining whether the first version of the shared library is eligible to be shared among the plurality of software applications on the second computing device includes: The first computing device determines the number of upload messages for the first version of the shared library, including applications; and After determining that the number of upload messages referencing the first version of the shared library is greater than or equal to a threshold, the first version of the shared library is determined to be eligible for sharing.

8. The computer-implemented method according to claim 1, wherein, The instruction also includes information about whether the second computing device supports a shared feature set, and wherein the executable file for transmitting the software application further includes: The first computing device determines whether the second computing device supports the shared function set based on the indication; and After determining that the second computing device does not support the shared feature set, the complete executable file of the software application is transmitted.

9. The computer-implemented method according to claim 8, wherein, The executable file for transmitting the software application also includes: After determining that the second computing device supports the shared feature set, the stripped executable file of the software application is transmitted.

10. The computer-implemented method according to claim 1, further comprising: Receive a complete software package containing the complete executable file of the software application at the first computing device; and The first computing device removes at least the first version of the shared library from the full executable file to create a corresponding stripped package that includes the stripped executable file, wherein the stripped package includes information about the set of features removed from the full executable file.

11. The computer-implemented method according to claim 1, wherein, The first version of the shared library is a software library, wherein the stripped executable does not include the software library, and wherein the complete executable includes the software library.

12. The computer-implemented method according to claim 1, wherein, The stripped executable file has a smaller file size compared to the complete executable file.

13. The computer-implemented method according to any one of claims 1-12, wherein, The data indicating the stability of one or more versions of the shared library includes historical data indicating the stability of one or more past versions of the shared library.

14. A computing device, comprising: One or more processors; as well as Data storage, the data storage comprising at least computer-executable instructions stored thereon, which, when executed by the one or more processors, cause the computing device to perform the method according to any one of claims 1-13.

15. A non-transitory computer-readable medium having instructions stored thereon, the instructions, when executed by one or more processors of a computing device, causing the computing device to perform the method according to any one of claims 1-13.

Images