Automatically building and configuring applications according to selected features

Abstract

The technology relates to generating a deliverable image (122) of a product. This may include: selecting a set of feature options corresponding to a product and a product operating system (704); generating a graphical interface comprising a set of input options regarding the product and a set of input options regarding the operating system and links between the sets of input options, where the interface restricts user selection of the links between the product input options and the operating system input options (706); receiving a selection of a product input option and an operating system input option (708); receiving a selection of a link between the selected product option and the operating system option (710); obtaining a set of components corresponding to the received selection (712); and assembling the set of components into a deliverable image of the product, the assembling including automatically linking components of the product with components of the operating system according to the selected link (714).

Description

CROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This application claims priority to and the benefit of the filing date of U.S. Patent Application No. 17 / 980,659, filed on November 4, 2022, the entire disclosure of which is expressly incorporated herein by reference. Background Art

[0002] Product assembly for computing devices typically involves customizing software packages to include specifically configured modules and feature sets to be run on a specific operating system. Configuration tools can be used to assist in the assembly process for software for a given product. However, developers may need detailed knowledge about the operating system to select appropriate modules and features for a given product. The entire assembly process may involve product assembly, in which components of a computing platform (e.g., an operating system) are combined with software components for a product to create a project set. The project set can then be used during the process of creating an executable software binary file such as an image assembly to obtain all compiled software components, which are put together into a deliverable image to be installed on a computing device. The deliverable image may include a flashable system image and other optionally installed software packages.

[0003] Updates to operating systems / platforms or products may need to go through the entire assembly process each time there is a change. For example, operating system feature updates may affect kernel configuration files because the project may have been renamed or moved. Re-assembly processes may be resource-intensive, especially when product-related information outside the source code of the operating system ("out of the tree") needs to be merged with the operating system / platform information "in the tree". The in-tree method involves using all the source files of the operating system and compiling the operating system at the same time as the components of the product. On the contrary, the out-of-tree method may not have the source files for the operating system, and may not compile the operating system at the same time as the product. The technical problem in such cases is that the configuration tool can only work with in-tree elements and without out-of-tree elements. When newer versions are pushed to different devices, this may be particularly problematic for managed operating systems. Another technical problem is to maintain an appropriate level of security during product assembly. This is done to ensure that platform components cannot be arbitrarily replaced with untrusted software, and the platform only calls components provided by the product in designated places where this is expected to occur. Summary of the invention

[0004] Aspects of the present technology include product development kit resources that give product developers a tool layer that includes built-in knowledge without requiring developers to understand platform details. Developers can select components at the feature level without the granularity of identifying specific software-level elements, which is originally required for product and image assembly. This allows the features of the implanted platform to evolve without the coordination of the product (and vice versa). This solves the technical problem of supporting updates to the platform separately from updating the product. These resources do not provide users with direct access to platform artifacts. They also automatically ensure that components are selected and configured in a safe manner. This approach can help prove that a fully assembled package with both platform components and product components will not execute any untrusted software, and that there are no changes to the underlying operating system platform components.

[0005] According to one aspect, a computer-implemented method is provided, the computer-implemented method comprising: receiving, by one or more processors of a computing system, a request to generate a deliverable image of a product; selecting, by the one or more processors in response to the request, a feature option set corresponding to the product and an operating system associated with the product; generating, by the one or more processors, a graphical interface configured to be presented to a user based on the selected feature option set, the graphical interface comprising an input option set regarding the product and an input option set regarding the operating system and a link between the input option set regarding the product and the input option set regarding the operating system, wherein the graphical interface restricts user selection of a link between the product input option and the operating system input option; receiving a selection of one or more product input options and one or more operating system input options; receiving a selection of a link between the selected one or more product options and the selected one or more operating system options; obtaining, by the one or more processors, a component set corresponding to the received selection of the one or more product input options and the one or more operating system input options from one or more component stores; and assembling, by the one or more processors, the obtained component set into a deliverable image of the product, the assembly comprising automatically linking components of the product with components of the operating system based on the selected link.

[0006] In one example, assembling a component set into a deliverable image of a product includes verifying the assembly configuration to ensure that there is a correct component set to produce the deliverable image. Alternatively or additionally, the graphical interface generated to include a set of input options for an operating system does not include any platform internal components of the operating system. Alternatively or additionally, obtaining a component set includes retrieving product-related components from a given storage associated with the product in one or more component stores. Here, obtaining a component set may further include directly retrieving operating system-related components from an operating system component store. And the one or more component stores associated with the product may include at least one of a product component store, an external component store, or a driver component store.

[0007] As an alternative or supplement to the above, assembling the component set into a deliverable image of a product may include constraining one or more configuration values ​​in the deliverable image. Here, the one or more configuration values ​​may include at least one pair of configuration values, and constraining the one or more configuration values ​​will then include preventing the pair of configuration values ​​from being used together. Alternatively or in addition, constraining the one or more configuration values ​​includes limiting access to a given resource to a specific operating system component.

[0008] As an alternative or supplement to the above, any component from the component set corresponding to one or more operating system input options can be a hashed operating system component.Alternatively or additionally, the method can further include: receiving a request to modify a deliverable image; updating a configuration file of the deliverable image in response to receiving the request; and compiling a modified version of the deliverable image without recompiling any components associated with the operating system.

[0009] Alternatively or in addition to the above, the set of input options for the product may correspond to a compiled component of one or more product features. Alternatively or additionally, the method may further include storing the deliverable image in a product release archive. Alternatively or additionally, the method may further include sending the deliverable image to one or more product devices for installation on the one or more product devices.

[0010] According to another aspect, a system is provided, the system comprising: a component storage set, each component storage in the component storage set being configured to store a specific type of software component; and one or more processors, the one or more processors being operably coupled to the component storage set. The one or more processors are configured to: receive a request to generate a deliverable image of a product; select a feature option set corresponding to the product and an operating system associated with the product in response to the request; generate a graphical interface configured to be presented to a user according to the selected feature option set, the graphical interface comprising an input option set about the product and an input option set about the operating system and a link between the input option set about the product and the input option set about the operating system, wherein the graphical interface is configured to limit user selection of the link between the product input option and the operating system input option; receive a selection of one or more product input options and one or more operating system input options; receive a selection of a link between the selected one or more product options and the selected one or more operating system options; obtain a component set corresponding to the received selection of the one or more product input options and the one or more operating system input options from the component storage set; and assemble the obtained component set into a deliverable image of the product, the assembling comprising automatically linking components of the product with components of the operating system according to the selected link.

[0011] In one example, assembling a component set into a deliverable image of a product includes verifying the assembly configuration to ensure that the correct component set exists to produce the deliverable image. Alternatively or additionally, obtaining the component set may include retrieving product-related components from one or more component stores associated with the product in a component storage set. Alternatively or additionally, assembling the component set into a deliverable image of a product may include constraining one or more configuration values ​​in the deliverable image. Here, constraining one or more configuration values ​​may include limiting access to a given resource to a specific operating system component.

[0012] As an alternative or in addition to the above, the one or more processors may be further configured to: receive a request to modify a deliverable image; update a configuration file of the deliverable image in response to receiving the request; and compile a modified version of the deliverable image without recompiling any components associated with the operating system. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Figure 1 is a process diagram according to various aspects of the present technology.

[0014] Figure 2 The use of an assembly tool in accordance with aspects of the present technique is shown.

[0015] FIG. 3A to FIG. 3B A graphical interface in accordance with aspects of the present technique is shown.

[0016] FIG. 4A to FIG. 4C An example computing device is shown that may be employed in accordance with aspects of the present technology.

[0017] Figure 5 A block diagram is shown of an example computing device that may be employed in accordance with aspects of the present technique.

[0018] FIG. 6A to FIG. 6B A system for use with various aspects of the present technology is shown.

[0019] Figure 7 Methods according to various aspects of the present technology are shown. DETAILED DESCRIPTION Overview

[0020] Streamlined product development tools enable developers to select components at a feature level in such a way that product-related components and platform components can be efficiently integrated into a deliverable image. The deliverable image can then be installed on many computing devices for a given product type. Product developers can assemble and provide deliverable images in a way that is decoupled from platform distribution and does not make changes to underlying platform components. This can be done via a managed operating system approach.

[0021] For example, a wireless communication configuration utilized by the platform can be updated on a user's product such as a home assistant (e.g., via an over-the-air update) without affecting product-specific features. In conventional approaches, a developer would need to identify each wireless communication component, such as a driver, configuration file, etc., and then adjust the configuration if any component is renamed. This can be time consuming, and the developer may make choices that may enable the execution of untrusted software elements, or otherwise be unable to determine which choices should be made in order to configure the system as desired.

[0022] In contrast, the product developer toolkit approach as described herein allows developers to identify the minimum required feature set from different categories. The identified feature set is then used by the product developer toolkit to select a single cluster of components necessary to support wireless communication services (or another technical element to be supported by the product). As an example, developers will name the high-level features they need, and the tool knows which components within the platform are needed to satisfy those requests for features, which may include corresponding drivers, configuration files, and / or other components. The tool automatically enables the product assembly process to build a bootable, flashable, updateable package. Developers can use tools to change the capabilities of the platform without recompiling or using runtime flags, which provides powerful control for developers. The product assembly process can be used to ensure that appropriate links and permissions are set so that untrusted software will not be executed. Platform components are hashed so that people can confirm that changes have not been made to the underlying operating system. Example Method

[0023] Figure 1 An example 100 of a high-level product assembly process according to aspects of the present technology is shown, where the platform (e.g., according to a particular operating system) is "in-tree" and the product is "out-of-tree". At block 102, a platform build is performed. This may have been previously completed by the operating system developer. The operating system SDK and components associated with the operating system may be stored in a platform component store 104. This store may include signed metadata for the operating system and / or individual components.

[0024] exist Figure 1 106, external software build 108, and out-of-tree driver build 110. These builds generate compiled components (components), and the outputs from the build elements 106 to 110 can be maintained in the product's component store 112, external component store 114, and out-of-tree driver component store 116, respectively. Because the out-of-tree software is configured for the platform, the platform provides instructions, tools, libraries, etc. to the out-of-tree build system for use. This is shown via the flow from the platform component store 104 to the build boxes 106, 108, and 110.

[0025] For example, a product's component store 112 may include compiled components for a particular product feature. By way of example only, this may be a pedometer, a blood pressure monitor, or other module for use in a wearable device. External component store 114 may include compiled third-party drivers. Conversely, platform component store 104 may hold compiled communication components of an operating system (e.g., a network stack and / or a Bluetooth™, WiFi, or near field communication (NFC) module). Developers may use a product assembly tool to pick the correct pre-built project from the store.

[0026] The artifacts are sent to a product assembly environment 118 where they can then be merged into a product image based on what features have been selected.

[0027] As an example, a user such as a product developer can use one or more product development tools to select which components associated with the operating system are to be incorporated into the product software package. The user can be presented with a selected set of features that can be selected. These features can be related to hardware options or other features associated with the platform, such as whether to enable one or more communication options of the product (e.g., Bluetooth™, WiFi and / or NFC). There can also be product-specific features. The selected features can be stored in a file, such as in a configuration file. As an example, the configuration file can be a JavaScript object notation (json) type file, but other file types can also be used. Based on the user selections in the configuration file, the product assembly environment 118 downloads the necessary components and any other associated information, such as a platform SDK, as shown in box 120.

[0028] A configuration assembly tool or other program may be run at box 121, which produces an assembled product image at box 122. According to one aspect of the present technology, the assembly tool may be part of the platform SDK itself. The assembly process may include validating the assembly configuration to ensure that the correct components are present to produce the desired image, and linking the configuration, product-provided packages, drivers, and kernel (and other components) together into an operating system volume manager (FVM) image that is configured to be flashable for the device. This includes automatically ensuring that components for the product image will function in a strict lockdown mode in which untrusted software will not be executed and software components will only be extracted from trusted locations.

[0029] The process can generate verified boot artifacts (e.g., these artifacts are hashed) to ensure that the image can be safely launched on the device, and can also generate an update package that will allow existing devices to be updated over the air (OTA) to the new version. Once the product image is created at box 122, the product image can be stored in a release archive 124 for rollout to a set of devices "in the wild" and / or to a target development device at box 126 for developer evaluation. In addition, as shown by the dotted line 128, there can be a direct link between the platform component store 104 and box 120. As an example, a platform component can be built within a tree and then published to a platform component store, which is then used by the build of boxes 106 to 110, and also used directly by the assembly step 121 itself (via direct download into box 120).

[0030] After the product image has been created, the developer may decide to replace, change, or otherwise modify the product image. For example, the developer may select a newer version of a driver, or select a WiFi communication feature instead of a Bluetooth™ communication feature. As an example, a configuration file may be updated to add a package to a product package list. An assembly is performed to merge the modified components (to build a new image of the product according to the modified configuration), and then the product image is flashed to deploy the product image to the device. Such modifications to the product image may be done without recompiling any operating system components (e.g., without recompiling the entire kernel). The only step required here would be to reassemble the already compiled components into a new image.

[0031] This is a powerful technical solution that avoids a complete recompilation of the operating system (platform) features when changes are made to product features (and vice versa). In particular, none of the hashes of the security-critical code have changed, which means that the security properties of the resulting image will be easier to verify. The assembly process is much faster than recompiling the entire operating system image. If the product owner needs support, the team managing the operating system will know that the developers are running the code originally produced by the operating system team without any deviation. In addition, updates to the platform and to the products can be made separately.

[0032] One aspect of the present technology limits developer options while having assembly tools automatically make appropriate links (without developer input) to ensure that the process works correctly and that untrusted software cannot be exploited. The approach creates a "product / platform boundary." The boundary allows things on one side to be changed without the other side being aware of the change. For example, it allows the operation of the system to be constrained to a safer mode. It also allows values ​​used to configure the platform to be verified to be within expected (e.g., tested) ranges and that platform components are not receiving unreviewed, potentially invalid inputs.

[0033] This can be accomplished through a number of mechanisms. First, the system is able to control the content of certain configuration values ​​in the image, such as not allowing the content to contain arbitrary input from the developer, but only values ​​constrained by the assembly tool. Second, in cases where a set of components can be given access to some resource, the assembly tool uses the knowledge of what is "from the platform" versus what is "from the product" to ensure that only specific platform components are given access to that resource. Furthermore, components provided by the developer (called product components) can only be connected to the platform at very specific points where the platform has been designed to have product components attached.

[0034] Regarding constrained values, the assembly tool may contain logic within the distributed tool that prevents certain values ​​from being used together. For example, it may not be possible to have two update checkers on a system, so the tool's parsing of configuration parameters will prevent this from happening. However, it may be possible to have two WiFi chipsets, so the assembly tool should allow for this. Configuration parameter patterns (for mutual exclusion of values, etc.) can be designed on a case-by-case basis.

[0035] To differentiate between "from the platform" and "from the product", the assembly tool may only support how to configure the platform. In other words, the assembly tool is assigned by the platform and therefore does not know how the product works. The assembly tool can be used to create products, but there may be no built-in mode for configuring any given product. Products can be built from a set of primitives provided by the platform, such as product packages, product components, and product configurations of platform features. This set of primitives can be strictly constrained.

[0036] The approaches discussed in this article can limit the connection of product components to the platform at specific points: As an example, the platform can intentionally limit the platform configuration surface. For example, the platform may explicitly not allow two updates to check for packages because this may be incorrect or otherwise cause errors. This is a key difference between an "image assembly", which can take any valid set of packages and put them together into an image, and a "product assembly", which has a semantic understanding of how the platform should be configured. Product assemblies (tools that are being provided to products) are implemented using image assemblies, but image assemblies may not be exposed to products unless there is a special reason to circumvent what the platform intentionally provides.

[0037] Thus, it can be seen that, although the assembly tool itself has a deep understanding of the platform, the assembly tool is configured to effectively present certain aspects to the user as a black box, which only provides the user with a very streamlined set of ways in which the product can configure things. Thus, rather than allowing the product's software to connect to any part of the platform, the assembly tool will instead only allow the product to connect at predefined places using prohibited interfaces, for example, so that the product can only communicate with the platform in ways that have been deemed safe and tested. And because the assembly tool contains its own logic about what is allowed / not allowed, the assembly tool is able to enforce mutual exclusivity of options.

[0038] As described above, the method may include verifying the assembly configuration to ensure that the correct components exist and are correctly linked together. In one case, the user interface tool provides a selected feature set to be selected from the developer, including an input option set about the product and an input option set about the operating system. For example, in order to build a product image, there may be dozens or hundreds of packages with even more files that would normally be included in the configuration data packet. There may be dozens of kernel startup components and hundreds of files to be placed in the boot file system. Therefore, in conventional methods, developers may have hundreds or even thousands of elements to evaluate and select. On the contrary, the selected feature set can omit any platform internal components, and very low-level options such as memory configuration or security mechanisms can also be omitted. Here, the tool can provide developers with the ability to input the minimum amount of information about the product (e.g., hardware specifications or other product requirement sets), as well as options to include or exclude advanced operating system features (e.g., WiFi support, automatic update sources and any / or additional hardware drivers that may be required). This can include providing an SDK for the operating system to select the required hardware options to be included in the configuration file.

[0039] As an example, this may include providing communication options where the developer can select one or more communication elements (e.g., Bluetooth™, WiFi, or NFC). The developer does not need to know how these specific elements will interoperate with the operating system components. In fact, the tool may limit (or prevent) the developer's ability to select elements and links to avoid the possibility of executing untrusted software. For example, the developer may not be provided with direct access to the platform components.

[0040] Instead, the tool will assess the product, the selected software elements, and then automatically make the appropriate connections for assembly. For example, this can include selecting the appropriate driver to use with the Bluetooth™ stack. The assembly will connect the driver and stack together in a secure manner, where the auditor can confirm that the integrity of the code is intact and no changes have been made, resulting in a trusted relationship.

[0041] In one case, the user interface tool may be presented in the form of a command line prompt. Here, as an example, a developer may enter information about a particular feature, such as: {feature_set_level: "minimal", build_type: "user" features: ["bluetooth", "network stack",]}. In another case, the graphical interface may include icons for selecting a particular feature and other elements to be incorporated into the product image.

[0042] Figure 2 A high-level diagram of using an assembly tool as discussed herein is shown. Developer 202 can interact with assembly tool 204 to Figure 1 The assembly process described above is used to generate the product image 206. Figure 3A An example of a user interface 300 for an assembly tool is shown. As shown, the user interface can provide a set of drop-down menus, such as a dashboard 302 (e.g., for selecting hardware or firmware elements), an update checker 304, an update configuration 306, etc. The user interface can also include a text box 308 so that the developer can enter information about the product. Alternatively or in addition, the UI 300 can employ a command line input section 310.

[0043] exist Figure 3B In one example 320 shown in FIG. Figure 3AThe kanban drop-down box 302 of has been selected. Here, depending on the specific features supported by the kanban, the drop-down box may show a set of options for a specific component such as WiFi. In this example, the UI may show options for WiFi only 322, WiFi plus near field communication (NFC) 324, WiFi plus Bluetooth™ 326, and / or WiFi plus NFC plus Bluetooth™. In this case, the user can select which WiFi-related option should be enabled. It should be noted that the UI for the compilation tool provides mutual exclusion of certain elements. For example, selecting a kanban with WiFI (e.g., any one of 322 to 328) may also prompt the user to choose whether WiFi should be enabled. And for kanbans without WiFi, such enabling options should not be presented. Here, the kanban drop-down box may not present any WiFi options, or these options may be shown as grayed out (to indicate that they are not selectable). Example computing device

[0044] The present technology can be applied in a product assemblage of many different types of computing devices.Some such examples are shown in the accompanying drawings and discussed below.

[0045] Figure 4A A view 400 of an example desktop computing device 402 is shown. In this example, a single display 404 is shown, but multiple display devices may also be supported. In one case, the display 404 may be configured for tactile input using a stylus or for touch input using a user's finger to interact with a graphical user interface (GUI) 406 presented on the display. As shown, the computing device 402 may employ a wireless keyboard 408 and / or one or more trackpads or mouse pads 410, which may be part of a unit, or the keyboard may be separated from the trackpad / mouse pad or mouse-based input 410a. Alternatively, the keyboard and / or other user input may have a wired connection to the computing device 402. As shown in this example, the computing device has a bracket 412. One or more microphones 414 may be arranged along the bracket and / or along the housing of the integrated client device 402. While the computing device can be fixedly mounted to the stand 412, in an alternative configuration, the screen (with integrated components) can be detached from the stand, allowing the user to carry it around the home and use it remotely based on battery power. In other words, the client device can include an integrated housing that is (optionally removably or releasably) coupled to the stand 412.

[0046] In this example, a webcam or other integrated camera 416, which may include a privacy baffle or other features that prohibit image capture, is positioned along the housing of the computing device 402, and may be used for video conferencing, interactive games, and the like. Whenever the webcam 416 is in use, an indicator 418 such as an LED may be lit to alert the user. The integrated client device may include a separate camera or other imaging device 420 as part of a presence sensor. As shown, the webcam 416 and the imaging device 420 may each be positioned along the top border of the integrated client device housing. In some examples, these devices may be located at different locations along the integrated housing. Instead of the imaging device 420 or as a supplement to the imaging device, the integrated camera 416 may be used as part of the presence sensor. In other words, the presence sensor includes an image sensor configured to capture one or more images. The presence sensor may be configured to detect the presence of one or more people within a threshold distance from the client computing device.

[0047] Figure 4B A view 440 of an example laptop computer 442 such as a netbook is shown. In this example, a display 444 is shown. In one case, the display 444 can be configured for tactile input using a stylus or touch input using a user's finger to interact with a graphical user interface (GUI) 446 presented on the display. As shown, the laptop computer 442 can use a keyboard 448 and / or one or more touch pads 450a and / or a mouse pad 450b. These input devices 448 and 450 can be virtual input devices presented on a second display 444'. In this case, the laptop computer 442 can also be used as a dual-screen device. One or more microphones 452 can be set along the housing of the computer 442. The laptop computer 442 can include a webcam or other integrated camera 454, which can include a privacy baffle or other features that prohibit image capture and is positioned along the housing, and the webcam or other integrated camera can be used for video conferencing, interactive games, etc. Whenever the webcam 454 is in use, an indicator 456 such as an LED can be lit to warn the user. Similar to computing device 402 , laptop computer 442 may include a separate camera or other imaging device in addition to webcam 454 as part of a presence sensor.

[0048] Figure 4CA view 460 of an example interactive home appliance 462, such as a home assistant device, is shown. In this example, a display 464 is shown. In this example, the appliance 462 does not include a keyboard. In one scenario, the display 464 can be configured for tactile input using a stylus or touch input using a user's finger to interact with a graphical user interface (GUI) 446 presented on the display. As an alternative or in addition to this, the interactive home appliance 462 can be configured to detect contactless gesture input, such as using a proximity radar sensor (not shown), an acoustic sensor (e.g., a microphone array) 468, a camera such as a webcam 4, etc. In this arrangement, the camera 470 can be part of the presence sensor. FIG. 4A to FIG. 4C The devices shown in are merely exemplary. For example, the interactive appliance may be a smart speaker or a smart thermostat (or other smart appliance), which may not include a camera and may have an LED instead of a display device.

[0049] Figure 5 A block diagram 500 of an example computing device is shown, such as a desktop device, a laptop device, or an interactive home appliance type device discussed above. As shown, the computing device includes a processing module 502, which has one or more computer processors such as a central processing unit 504 and / or a graphics processor 506 and a memory module 508 configured to store instructions 510 and data 512. The processor may or may not operate in parallel, and may include an ASIC, a controller, and other types of hardware circuitry. The processor is configured to receive information from a user through a user interface module 514, and present information to the user on a display device of a display module 516 via the user interface module. The display module 516 has a display interface, and may be configured to be a touch screen that implements user input via a stylus or other tool or by a user physically touching the screen. Alternatively or in addition, contactless gesture input and / or audio input may be supported.

[0050] The user interface module 514 is configured to receive user input. The user interface module 514 can receive commands from the user via user input, and convert these commands to submit to a given processor. The user interface module can be linked to a web browser (not shown). As a supplement or alternative to a keyboard, keypad, mouse pad and / or touchpad, microphone, gesture-based input or other types of input devices, the user input can include a touch screen as stated above. The keyboard, keypad, mouse pad and / or touchpad can be part of the computing device, or can be connected to the computing device via a cable or other wired connection, or can be physically separated from the integrated client device and configured to be connected via one or more wireless connections such as Bluetooth™, WiFi, ultra-wideband (UWB), infrared. The user interface module 514 can be operably connected to the display module 516.

[0051] The display module 516 may include a circuit system for driving a display device to present graphical information and other information to a user. In other words, the display device is configured to present visual content. As an example, the graphical information may be generated by the graphics processor 506, while the central processing unit (CPU) 504 manages the overall operation of the computing device. The graphical information may be displayed on the display module 516 in response to a user query. For example, the processing module may use the instructions and data stored in the memory module 508 to run a browser application, a game application, an enterprise app, or other service, and present information to the user via the display module 516. The memory module 508 may include a database or other storage device for browser information, game state information, location information, etc.

[0052] The memory module 508 may be implemented as one or more of the following: one or more computer-readable media, one or more volatile memory units, or one or more non-volatile memory units. The memory module 508 may include, for example, unmanaged flash memory and / or NVRAM (which may be NAND-based memory), and may be embodied as a hard drive or memory card, such as an embedded multimedia card (eMMC) or a solid-state drive (SSD) card (e.g., "managed NAND" or "managed memory"). Alternatively, the memory module 508 may also include removable media (e.g., a DVD, CD-ROM, or USB thumb drive). According to one aspect, the memory module 508 may be configured to have multiple partitions.

[0053] One or more areas of memory module 508 may be writable, while other areas may include read-only (or otherwise write-protected) memory. In one implementation, a computer program product is tangibly embodied in an information carrier. Figure 5 The processors, memory modules, and other elements of the integrated client device are shown functionally as being within the same overall block, but such components may or may not be stored within the same physical housing. For example, some or all of the instructions and data may be stored on an information carrier that is a removable storage medium (e.g., an optical drive, a high-density tape drive, or a USB drive) that is connectable to a base or display housing, and other instructions and data are stored within a read-only computer chip integrated into the base or display housing.

[0054] Data 512 can be retrieved, stored or modified by the processor according to instructions 510. For example, data can be stored in a computing device register, in a relational database as a table with multiple different fields and records, in an XML document or a flat file. Data can also be formatted in any computing device readable format. Instructions 510 can be any instruction set (such as machine code) to be executed directly by the processor or any instruction set (such as a script) to be executed indirectly. For example, instructions can be stored as computing device code on a computing device readable medium. In this regard, the terms "instructions" and "programs" can be used interchangeably herein. Instructions can be stored in an object code format for direct processing by the processor, or in any other computing device language, including scripts or independent source code module sets that are interpreted or compiled in advance on demand.

[0055] Also like Figure 5 As shown in example 500 of , the computing device includes a communication module 518 for communicating with other devices and systems, including other computing devices (e.g., a user's mobile phone or wearable computing device), servers, and databases. The communication module 518 includes a wireless transceiver; alternatively, the module may alternatively or additionally include a wired transceiver. The computing device can communicate with other remote devices via the communication module 518 using a variety of configurations and protocols, including short-range communication protocols such as near field communication (NFC), Bluetooth™, Bluetooth™ low energy (BLE), UWB or other ad hoc networks, the Internet, an intranet, a virtual private network, a wide area network, a local area network, a private network using one or more company-proprietary communication protocols, Ethernet, WiFi, and HTTP, and combinations of the foregoing.

[0056] In addition, the example device as shown includes one or more position and orientation sensors 520. The position and orientation sensors 520 are configured to determine the position and orientation of one or more parts of the computing device (such as a display module) relative to the base. For example, these components may include a GPS receiver for estimating the latitude, longitude and / or altitude of the integrated client device, and an accelerometer, gyroscope, or another direction / speed detection device such as an inertial measurement unit (IMU) that can determine the orientation of the display housing relative to the base (and the rate of change of the orientation of the display housing).

[0057] The computing device may also include one or more cameras 522 for capturing still images and recording video streams, such as an integrated webcam and / or a dedicated imaging device for presence sensing as discussed above. The device may also include one or more microphones 523 (which may be used for command input and / or presence sensing, e.g., by detecting acoustic information within a threshold distance from the client device), a speaker 524, and a power module 526. An actuator for providing tactile feedback or other information to the user may be incorporated into a touch screen of a display module (not shown). Example Network

[0058] Can use the product compilation process discussed above to update various types of products.In different situations, can be on all devices in a product line, subset (part) of devices of a product line, on multiple different product lines, etc. to perform the update. Fig. 6A and Figure 6B An example computing architecture that can be employed in these methods is shown in FIG. In particular, Fig. 6A and Figure 6B 606. FIG607 is a diagram of an example system 600 that includes multiple computing devices and databases connected via a network. For example, computing device 602 can be a cloud-based server system that provides or otherwise supports updates for various products. Database 604 can store updates and other information associated with products and / or platforms. The server system can access the database via network 606.

[0059] Developer device 608 may be a workstation or other computing device that can run a product SDK, which may include an assembly tool. Products may include one or more of a desktop computer 610a, a laptop or tablet PC 610b, a home device such as a removable unit (such as a home assistant device 612a or a smart speaker 612b) or a fixed unit (such as a temperature / thermostat unit 612c). Other products may include personal communication devices such as mobile phones or PDAs 614 or wearable devices such as smart watches 616, etc.

[0060] In one example, computing device 602 may include one or more server computing devices having multiple computing devices, such as a load balancing server farm or a cloud computing system, which exchange information with different nodes of a network to receive data from other computing devices, process data, and transmit data to other computing devices. For example, computing device 602 may include one or more server computing devices capable of communicating with development device 608 and any one of products 610 to 616 via network 606. Here, the server computing device may implement one or more product update services, which may correspond to different types of products.

[0061] like Figure 6B As shown, each of the computing device 602, the developer device 608, and the products 610 to 616 may include one or more processors, memory, data, and instructions. The memory stores information accessible by one or more processors, including instructions and data that can be executed or otherwise used by the processor. The memory may be any type of memory capable of storing information accessible by the processor, including a computing device readable medium. The memory is a non-temporary medium such as a hard disk, a memory card, an optical disk, a solid state, etc. The system may include different combinations of the foregoing, thereby storing different parts of the instructions and data on different types of media. The instruction may be any instruction set (such as a machine code) to be directly executed by the processor or any instruction set (such as a script) to be indirectly executed. For example, the instruction may be stored as a computing device code on a computing device readable medium. In this regard, the terms "instruction", "module", and "program" may be used interchangeably herein. The instruction may be stored in an object code format for direct processing by the processor, or in any other computing device language, including a script or independent source code module set that is interpreted or compiled in advance on demand.

[0062] The processor may be any conventional processor, such as a commercially available CPU. Alternatively, each processor may be a dedicated device, such as an ASIC, a graphics processing unit (GPU), a tensor processing unit (TPU), or other hardware-based processor. Figure 6B The processor, memory, and other elements of a given computing device are functionally shown as being located within the same box, but such a device may actually include multiple processors, computing devices, or memories that may or may not be stored within the same physical housing. Similarly, the memory may be a hard drive or other storage medium located in a housing different from that of the processor (e.g., located in a cloud computing system such as server 602). Therefore, references to a processor or computing device will be understood to include references to a collection of processors or computing devices or memories that may or may not operate in parallel.

[0063] Developer device 608 and products 610 to 616 may include all components commonly used in conjunction with a computing device, such as the processor and memory described above, as well as a user interface subsystem for receiving input from a user and presenting information (e.g., text, images, and / or other graphical elements) to the user. The user interface subsystem may include one or more user inputs (e.g., at least one front (user) camera, mouse, keyboard, touch screen, and / or microphone) and one or more display devices operable to display information (e.g., text, images, and / or other graphical elements). Other output devices such as speakers may also provide information to the user.

[0064] Development device 608 and / or products 610-616 may communicate with backend computing systems (e.g., server 602) via one or more networks such as network 606. Network 606 and intermediary nodes may include various configurations and protocols including short-range communication protocols such as Bluetooth™, Bluetooth LE™, the Internet, the World Wide Web, an intranet, a virtual private network, a wide area network, a local network, a private network using one or more company-proprietary communication protocols, Ethernet, WiFi, and HTTP, and various combinations of the foregoing. Such communications may be facilitated by any device capable of transferring data to and from other computing devices, such as a modem and a wireless interface. Exemplary Operation Methods

[0065] Figure 7A computer-implemented method 700 embodying aspects of the present technology is shown. The method includes: at box 702, receiving, by one or more processors of a computing system, a request to generate a deliverable image of a product. At box 704, the method includes selecting, by the one or more processors, a feature option set corresponding to the product and an operating system associated with the product in response to the request. Then, at box 706, the method includes generating, by the one or more processors, a graphical interface configured to be presented to a user based on the selected feature option set. The graphical interface includes an input option set for the product and an input option set for the operating system and a link between the input option set for the product and the input option set for the operating system. The graphical interface restricts user selection of a link between the product input option and the operating system input option. At box 708, the method includes receiving a selection of one or more product input options and one or more operating system input options, and at box 710, receiving a selection of a link between the selected one or more product options and the selected one or more operating system options. At box 712, the method includes obtaining, by the one or more processors, from one or more component stores, a component set corresponding to the received selection of the one or more product input options and the one or more operating system input options. Then, at box 714, the method includes assembling the obtained component set into a deliverable image of the product by one or more processors. Here, assembling includes automatically linking the components of the product with the components of the operating system according to the selected links.

[0066] Although the technology herein has been described with reference to specific embodiments, it should be understood that these embodiments are only illustrative of the principles and applications of the present technology. Therefore, it should be understood that various modifications may be made to the illustrative embodiments, and other arrangements may be designed without departing from the spirit and scope of the present technology as defined by the appended claims.

Claims

1. A computer-implemented method comprising: Receiving, by one or more processors of a computing system, a request to generate a deliverable image of a product; selecting, by the one or more processors in response to the request, a set of feature options corresponding to the product and an operating system associated with the product; generating, by the one or more processors, a graphical interface configured to be presented to a user according to the selected feature option set, the graphical interface comprising an input option set for the product and an input option set for the operating system and a link between the input option set for the product and the input option set for the operating system, wherein the graphical interface restricts user selection of the link between the product input option and the operating system input option; receiving a selection of one or more product input options and one or more operating system input options; receiving a selection of a link between the selected one or more product options and the selected one or more operating system options; Obtaining, by the one or more processors, from one or more component stores, a set of components corresponding to the received selections of one or more product input options and one or more operating system input options; and The one or more processors assemble the obtained component set into the deliverable image of the product, the assembling including automatically linking the components of the product with the components of the operating system according to the selected links.

2. The method according to claim 1, in, Assembling the set of components into the deliverable image of the product includes validating an assembly configuration to ensure that the correct set of components is present to produce the deliverable image.

3. The method according to claim 1, in, The graphical interface generated to include the set of input options for the operating system does not include any platform-internal components of the operating system.

4. The method according to claim 1, in, Obtaining the set of artifacts includes retrieving product-related artifacts from a given one of the one or more artifact stores that is associated with the product.

5. The method according to claim 4, in, Obtaining the component set further includes directly retrieving operating system related components from an operating system component storage.

6. The method according to claim 4, in, The one or more component stores associated with the product include at least one of a product component store, an external component store, or a driver component store.

7. The method according to claim 1, in, Assembling the set of components into the deliverable image of the product includes constraining one or more configuration values ​​in the deliverable image.

8. The method according to claim 7, in: The one or more configuration values ​​include at least one pair of configuration values; and Constraining the one or more configuration values ​​includes preventing the pair of configuration values ​​from being used with each other.

9. The method according to claim 7, in, Constraining the one or more configuration values ​​includes limiting access to a given resource to specific operating system components.

10. The method according to claim 1, in, Any component from the set of components corresponding to the one or more operating system input options is a hashed operating system component.

11. The method of claim 1, further comprising: include: receiving a request to modify the deliverable image; In response to receiving the request, updating a configuration file for the deliverable image; as well as The modified version of the deliverable image is compiled without recompiling any components associated with the operating system.

12. The method of claim 1, in, The set of input options for the product corresponds to a compiled assembly of one or more product features.

13. The method of claim 1, further comprising storing the deliverable image in a product release archive.

14. The method of claim 1, further comprising sending the deliverable image to one or more production devices for installation on the one or more production devices.

15. A system, include: A component storage set, each component storage in the component storage set is configured to store a specific type of software component; as well as One or more processors, the one or more processors operably coupled to the component storage set, the one or more processors configured to: receiving a request to generate a deliverable image of a product; selecting, in response to the request, a set of feature options corresponding to the product and an operating system associated with the product; generating a graphical interface configured to be presented to a user according to the selected feature option set, the graphical interface comprising an input option set about the product and an input option set about the operating system and a link between the input option set about the product and the input option set about the operating system, wherein the graphical interface is configured to restrict user selection of the link between the product input option and the operating system input option; receiving a selection of one or more product input options and one or more operating system input options; receiving a selection of a link between the selected one or more product options and the selected one or more operating system options; obtaining from the component store a component set corresponding to the received selection of one or more product input options and one or more operating system input options; and The obtained component set is assembled into the deliverable image of the product, and the assembly includes automatically linking the components of the product with the components of the operating system according to the selected links.

16. The system of claim 15, in, Assembling the set of components into the deliverable image of the product includes validating an assembly configuration to ensure that the correct set of components is present to produce the deliverable image.

17. The system of claim 15, in, Obtaining the component set includes retrieving product-related components from one or more component stores associated with the product in the component storage set.

18. The system of claim 15, in, Assembling the set of components into the deliverable image of the product includes constraining one or more configuration values ​​in the deliverable image.

19. The system of claim 18, in, Constraining the one or more configuration values ​​includes limiting access to a given resource to specific operating system components.

20. The system of claim 15, in, The one or more processors are further configured to: receiving a request to modify the deliverable image; In response to receiving the request, updating a configuration file of the deliverable image; and The modified version of the deliverable image is compiled without recompiling any components associated with the operating system.

Images