DETAILED ACTION
This is the initial Office action based on the application filed on July 8, 2024.
Claims 1-20 are pending.
Priority
Receipt is acknowledged of certified copies of papers required by 37 CFR 1.55.
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Drawings
The drawings are objected to as failing to comply with 37 CFR 1.84(p)(4) because reference character “11” has been used to designate both a server in Figure 1A and a hot reload control in Figure 1C. Corrected drawing sheets in compliance with 37 CFR 1.121(d) are required in reply to the Office action to avoid abandonment of the application. Any amended replacement drawing sheet should include all of the figures appearing on the immediate prior version of the sheet, even if only one figure is being amended. Each drawing sheet submitted after the filing date of an application must be labeled in the top margin as either “Replacement Sheet” or “New Sheet” pursuant to 37 CFR 1.121(d). If the changes are not accepted by the examiner, the applicant will be notified and informed of any required corrective action in the next Office action. The objection to the drawings will not be held in abeyance.
Claim Objections
Claims 2 and 11 are objected to because of the following informalities:
Claims 2 and 11, in lines 4-5 and lines 4-5 respectively, recite “the updated page.” It should read – the updated target page --.
Appropriate correction is required.
Claim Rejections - 35 USC § 112
The following is a quotation of 35 U.S.C. 112(b):
(b) CONCLUSION.—The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention.
The following is a quotation of 35 U.S.C. 112 (pre-AIA ), second paragraph:
The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention.
Claims 8-9 and 17-18 are rejected under 35 U.S.C. 112(b) as being indefinite for failing to particularly point out and distinctly claim the subject matter which the inventor or a joint inventor regards as the invention.
Claims 8-9 and 17-18 recite, in line 4, line 6, line 4, and line 6 respectively, the limitation “the page ingress logic code file.” There is insufficient antecedent basis for this limitation in the claim. In the interest of compact prosecution, the Examiner subsequently interprets the limitation as -- a page ingress logic code file – in Claims 8-9 and 17-18.
Claims 8-9 and 17-18 recite, in line 7, lines 6-7, line 7, and lines 6-7 respectively, the limitation “the non-page ingress logic code file.” There is insufficient antecedent basis for this limitation in the claim. In the interest of compact prosecution, the Examiner subsequently interprets the limitation as -- a non-page ingress logic code file– in Claims 8-9 and 17-18.
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1, 7, 10, 16, and 19-20 are rejected under 35 U.S.C. 103 as being unpatentable over CN 114035829A (Provided by Applicant’s IDS, hereinafter “Qin”) in view of “MiniApp Standardization White Paper” (Provided by Applicant’s IDS, hereinafter “Li”) and US 2020/0167153 (hereinafter “Wang 01”).
As per Claim 1, Qin discloses:
A method for updating a subroutine of an application performed by an electronic device, the method comprising:
receiving a modification operation on a logic code file of a target [application] (paragraph [n0060], “In some embodiments, in response to the callback function import.meta.hot.accept being triggered [received], that is, when the San component is detected to be updated, the reload function will be triggered through the callback function, and the updated San component will be transmitted to the reload function (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file [target logic code file] and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”);
registering a target component of the target page based on the target logic code file when an original component in the target page corresponding to the target logic code file is currently in a loaded state of the application (paragraph [n0052], “The attached lifecycle function is used to attach the component instance generated by the San component to the page when the page [target page] loads […] The registration function is used to record the mapping relationship between a new component instance [target component] and its corresponding component when a new component instance is generated, such as during page loading (emphasis added).”; paragraph [n0060], “The reload function first iterates through the mapping list to get all the component instances corresponding to the San component, and then updates these component instances. That is, based on the updated San component, it gets the updated second component instance [target component] to replace the first component instance before the update [original component] (emphasis added).”; paragraph [n0067], “[…] and a second recording subunit configured to, based on a registration function, record a second mapping relationship between the second component instance and the page component.”; paragraph [n0056], “For example, when a developer re-edits the San file [target logic code file] and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”) [Examiner’s Remarks: Note that Qin discloses a new/updated component instance replacing a component instance during page loading. Qin discloses a registration function recording a mapping relationship between a new component instance and its corresponding component. Qin also discloses a developer editing and saving a file which triggers each component instance to be updated based on the mapping relationship. One of ordinary skill in the art would readily comprehend that registering the target (new) component is based on the target logic code file since the registration function is used to record the relationship between the target component and its corresponding component as a result of the target logic code file being modified (edited) by a developer.];
updating the target page of the application by replacing the original component corresponding to the target logic code file with the target component corresponding to the target logic code file (paragraph [n0005], “According to one aspect of this disclosure, a method for updating a page component is provided, comprising: in response to running the page component, obtaining a first component instance of the page component, […] and in response to detecting that the page component [target page] has been updated, updating the first component instance based on the first mapping relationship (emphasis added).”; paragraph [n0010], “According to one or more embodiments of this disclosure, the mapping relationship between page components and page instances can be recorded, and when the component is updated, the instance corresponding to the component can be accurately found and updated accordingly, without having to update the entire project file, thereby improving the efficiency of the update (emphasis added).”; paragraph [n0060], “The reload function first iterates through the mapping list to get all the component instances corresponding to the San component, and then updates these component instances. That is, based on the updated San component, it gets the updated second component instance [target component] to replace the first component instance before the update [original component] (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file [target logic code file] and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”).
Qin discloses “receiving a modification operation on a logic code file of a target [application],” but does not explicitly disclose:
receiving a modification operation on a logic code file of a target subroutine.
However, Li discloses:
target subroutine (page 4, “MiniApp is a new format of mobile application […].”; page 5, “A miniapp can be distributed to multiple MiniApp platforms (the Web, a Native App, even the OS). These platforms also provide entry to the miniapp to ensure it can be easily discovered by the users.”).
Qin is within the same field of endeavor as the claimed invention regarding hot updating page components. Li is also within the same field of endeavor as the claimed invention regarding subroutines (MiniApps).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Li into the teaching of Qin to include “receiving a modification operation on a logic code file of a target subroutine.” The modification would be obvious because one of ordinary skill in the art would be motivated to utilize a MiniApp (subroutine) since it separates the View Layer (rendering pages) and Logic Layer (event processing) which is handy for data sharing and interaction among multiple MiniApp pages and can also help prevent JS execution impacting/slowing down page rendering which enhances the performance of rendering (Li, pages 9-10).
The combination of Qin and Li discloses “target subroutine,” but does not explicitly disclose:
when a modified target logic code file is not an ingress logic code file of the target subroutine, determining a corresponding user interface of the application as a target page associated with the target logic code file; and
displaying the updated target page, the updated target page comprising the target component.
However, Wang 01 discloses:
when a modified target logic code file is not an ingress logic code file of the target [application], determining a corresponding user interface of the application as a target page associated with the target logic code file (Figures 8, 10, & 12; paragraph [0027], “The visual indicators also allow software test engineers and other persons to visually distinguish UI elements of a product that have backend source code that has been changed from UI elements of the product that do not have changed backend source code (emphasis added).”; paragraph [0046], “This mapping or linking of the backend code with the frontend code helps determine which user interface element is affected when a portion of backend code changes [modified target logic code file is not an ingress logic code file] (416). After the analysis, the mapping between the frontend code and backend code are stored in a database 415 (emphasis added).”; paragraph [0060], “Accordingly, one or more embodiments of the present invention facilitate identifying user interface element by highlighting the user interface element in a rendered user interface during runtime based on changes in source code (emphasis added).”); and
displaying the updated target page, the updated target page comprising the target component (Figure 12; paragraph [0059], “FIG. 12 depicts a revised user interface 700B of the revised source code 800B that is represented in FIG. 10. The revised user interface 700B is depicted using the JSON object 1100 from FIG. 11. Using the highlight attributes from the JSON object 1100 the user interface elements corresponding to the revisions 1010 are flagged (1210) in the revised user interface 700B (emphasis added).”; paragraph [0027], “The visual indicators also allow software test engineers and other persons to visually distinguish UI elements of a product that have backend source code that has been changed from UI elements of the product that do not have changed backend source code (emphasis added).”).
Wang 01 is within the same field of endeavor as the claimed invention regarding detecting modified code files.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Wang 01 into the combined teachings of Qin and Li to include “when a modified target logic code file is not an ingress logic code file of the target subroutine, determining a corresponding user interface of the application as a target page associated with the target logic code file.” The modification would be obvious because one of ordinary skill in the art would be motivated to determine a corresponding UI of the application to effectively distinguish modified UI elements when backend code is modified in order to solve the problem of visually identifying UI elements that have an associated change in source code through UI flagging (Wang 01, paragraphs [0024 & 0027]).
As per Claim 7, the rejection of Claim 1 is incorporated; and Qin further discloses:
performing a hot reload process for the modified target logic code file when the modification operation carries a hot reload instruction (paragraph [n0056], “In some embodiments, the status of the San component can be detected by the callback function import.meta.hot.accept provided in the hot-reload component of Vite. For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above.”; paragraph [n0060], “In some embodiments, in response to the callback function import.meta.hot.accept being triggered, that is, when the San component is detected to be updated, the reload function will be triggered through the callback function, and the updated San component will be transmitted to the reload function.”; paragraph [n0036], “The method includes: step S201, in response to running the page component, obtaining a first component instance of the page component, wherein the page component includes a hot update plugin […] in response to detecting that the page component has been updated, updating the first component instance based on the first mapping relationship.”); and
determining the target page associated with the target logic code file by using the hot reload process (paragraph [n0056], “In some embodiments, the status of the San component can be detected by the callback function import.meta.hot.accept provided in the hot-reload component of Vite. For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above.”; paragraph [n0060], “In some embodiments, in response to the callback function import.meta.hot.accept being triggered, that is, when the San component is detected to be updated, the reload function will be triggered through the callback function, and the updated San component will be transmitted to the reload function.”; paragraph [n0036], “The method includes: step S201, in response to running the page component, obtaining a first component instance of the page component, wherein the page component includes a hot update plugin […] in response to detecting that the page component has been updated, updating the first component instance based on the first mapping relationship.”).
As per Claim 10, Qin discloses:
An electronic device, comprising a memory and a processor, the memory having a program stored therein, and the program, when executed by the processor, causing the electronic device to perform a method (paragraph [n0007], “[…] an electronic device is provided, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the above-described page component update method.”) for updating a subroutine of an application including: […].
Claim 10 is an electronic device claim corresponding to method Claim 1 and the remainder of Claim 10 is rejected for the same reasons as given in the rejection of Claim 1.
Claim 16 is an electronic device claim corresponding to method Claim 7 and is rejected for the same reasons as given in the rejection of that claim.
As per Claim 19, Qin discloses:
A non-transitory computer-readable storage medium, having a program stored therein, the program, when executed by a processor of an electronic device, causing the electronic device to perform a method (paragraph [n0008], “[…] a non-transitory computer-readable storage medium is provided storing computer instructions, wherein the computer instructions are used to cause a computer to perform the above-described method for updating page components.”; paragraph [n0077], “These program codes may be provided to the processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing device, such that when the program code is executed by the processor or controller, the functions/operations specified in the flowcharts and/or block diagrams are performed.”) for updating a subroutine of an application including: […].
Claim 19 is a non-transitory computer-readable storage medium claim corresponding to method Claim 1 and the remainder of Claim 19 is rejected for the same reasons as given in the rejection of Claim 1.
Claim 20 is a non-transitory computer-readable storage medium claim corresponding to method Claim 7 and is rejected for the same reasons as given in the rejection of that claim.
Claims 2 and 11 are rejected under 35 U.S.C. 103 as being unpatentable over Qin in view of Li and Wang 01 as applied to Claims 1 and 10 above, and further in view of US 2017/0147324 (hereinafter “Weber”).
As per Claim 2, the rejection of Claim 1 is incorporated; and Qin discloses “the modified target logic code file is the ingress logic code file of the target [application] (paragraph [n0052], “The attached lifecycle function is used to attach the component instance generated by the San component to the page when the page loads […] The registration function is used to record the mapping relationship between a new component instance and its corresponding component when a new component instance is generated, such as during page loading (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”),” but Qin does not explicitly disclose:
compiling the target logic code file when the modified target logic code file is the ingress logic code file of the target subroutine; and
restarting the target subroutine based on a compilation result, and displaying the updated page corresponding to the target logic code file through the restarted target subroutine.
However, Li discloses:
target subroutine (page 4, “MiniApp is a new format of mobile application […].”; page 5, “A miniapp can be distributed to multiple MiniApp platforms (the Web, a Native App, even the OS). These platforms also provide entry to the miniapp to ensure it can be easily discovered by the users.”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Li into the teaching of Qin to include “the modified target logic code file is the ingress logic code file of the target subroutine.” The modification would be obvious because one of ordinary skill in the art would be motivated to utilize a MiniApp (subroutine) since it separates the View Layer (rendering pages) and Logic Layer (event processing) which is handy for data sharing and interaction among multiple MiniApp pages and can also help prevent JS execution impacting/slowing down page rendering which enhances the performance of rendering (Li, pages 9-10).
The combination of Qin and Li does not explicitly disclose:
compiling the target logic code file when the modified target logic code file is the ingress logic code file of the target subroutine; and
restarting the target subroutine based on a compilation result, and displaying the updated page corresponding to the target logic code file through the restarted target subroutine.
However, Weber discloses:
compiling the target logic code file when the modified target logic code file is the [source code file] of the target [application] (paragraph [0093], “At a later time, a software developer may update source code for application 130 in such a way that does not allow application 130 to execute updated compiled targets in test environment system 364 without restarting application 130. Builder module 108 may compile the updated source code into one or more updated compiled targets of a hot-swap target subset as described above in FIG. 3, which include identifiers such as $override to indicate that the compiled targets have changed. Builder module 108 may also compile the updated source code into one or more updated compiled targets of a cold-swap target subset, which include compiled and uncompiled targets, based on the source code changes, that compiled according to the initial, rather than subsequent, compilation process as described above in FIG. 3 (emphasis added).”; paragraph [0022], “In some examples, a target is a single file. For instance, a target may be a file that includes a set of machine-executable code (e.g., “compiled target”) compiled from human-readable source code.”);
restarting the target [application] based on a compilation result (paragraph [0089], “In some examples, structural changes implemented by a software developer to source code in application 130 may not allow application 130 to execute updated compiled targets in test environment system 364 without restarting application 130.”; paragraph [0096], “Since application 130 includes data to identify the predefined location or directory for compiled targets that include machine-executable code and load such compiled targets in reverse chronological order, application 130 may be restarted with the newest compiled targets being loaded into memory for execution.”);
the restarted target [application] (see previous citation).
Weber is within the same field of endeavor as the claimed invention regarding the compilation of modified code files and restarting applications.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Weber into the combined teachings of Qin and Li to include “compiling the target logic code file when the modified target logic code file is the ingress logic code file of the target subroutine; restarting the target subroutine based on a compilation result; the restarted target subroutine.” The modification would be obvious because one of ordinary skill in the art would be motivated to compile a modified file and restart a target application/subroutine based on the compiled files in order to ensure changes that can’t be applied to an application/subroutine without restarting are effectively applied to the application/subroutine (Weber, paragraph [0014]).
The combination of Qin, Li, and Weber does not explicitly disclose:
restarting the target subroutine based on a compilation result, and displaying the updated page corresponding to the target logic code file through the restarted target subroutine.
However, Wang 01 discloses:
displaying the updated page corresponding to the target logic code file through the [application] (Figure 12; paragraph [0059], “FIG. 12 depicts a revised user interface 700B of the revised source code 800B that is represented in FIG. 10. The revised user interface 700B is depicted using the JSON object 1100 from FIG. 11. Using the highlight attributes from the JSON object 1100 the user interface elements corresponding to the revisions 1010 are flagged (1210) in the revised user interface 700B.”; paragraph [0027], “The visual indicators also allow software test engineers and other persons to visually distinguish UI elements of a product that have backend source code that has been changed from UI elements of the product that do not have changed backend source code.”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Wang 01 into the combined teachings of Qin, Li, and Weber to include “restarting the target subroutine based on a compilation result, and displaying the updated page corresponding to the target logic code file through the restarted target subroutine.” The modification would be obvious because one of ordinary skill in the art would be motivated to display an updated page of an application to effectively distinguish modified UI elements when backend code is modified in order to solve the problem of visually identifying UI elements that have an associated change in source code through UI flagging (Wang 01, paragraphs [0024 & 0027]).
Claim 11 is an electronic device claim corresponding to method Claim 2 and is rejected for the same reasons as given in the rejection of that claim.
Claims 3 and 12 are rejected under 35 U.S.C. 103 as being unpatentable over Qin in view of Li, Wang 01, and Weber as applied to Claims 2 and 11 above, and further in view of US 2010/0017702 (hereinafter “Carroll”).
As per Claim 3, the rejection of Claim 2 is incorporated; and Qin discloses “the target logic code file (paragraph [n0052], “The attached lifecycle function is used to attach the component instance generated by the San component to the page when the page loads […] The registration function is used to record the mapping relationship between a new component instance and its corresponding component when a new component instance is generated, such as during page loading.”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above.”)” and “the target page (see previous citation),” but the combination of Qin, Li, Wang 01, and Weber does not explicitly disclose:
analyzing a page dependency relationship on the target logic code file, to obtain a dependency page corresponding to the target logic code file, and determining the dependency page as the target page.
However, Carroll discloses:
analyzing a page dependency relationship on the target [object], to obtain a dependency page corresponding to the target [object], and determining the dependency page as the target page (abstract, “The method traverses the dependency graph and sends update requests to the web page or web pages displayed on the computer, wherein the update requests are sent to the object associated with the root node, and the other objects associated with the child nodes.”; paragraph [0002], “In particular, the present invention is a system and method for updating objects displayed on a web page or across multiple web pages of a web portal by dynamically computing a dependency graph.”).
Carroll is within the same field of endeavor as the claimed invention regarding updating pages.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Carroll into the combined teachings of Qin, Li, Wang 01, and Weber to include “analyzing a page dependency relationship on the target logic code file, to obtain a dependency page corresponding to the target logic code file, and determining the dependency page as the target page.” The modification would be obvious because one of ordinary skill in the art would be motivated to dynamically compute and analyze a page dependency relationship with each user interaction in order to allow only the rendering that is necessary to take place (avoid unnecessary renderings) and accommodate unknowable application behaviors, such as adding or removing an object on a page (Carroll, paragraph [0034]).
Claim 12 is an electronic device claim corresponding to method Claim 3 and is rejected for the same reasons as given in the rejection of that claim.
Claims 4 and 13 are rejected under 35 U.S.C. 103 as being unpatentable over Qin in view of Li and Wang 01 as applied to Claims 1 and 10 above, and further in view of CN 112162767A (Provided by Applicant’s IDS, hereinafter “Wang 02”).
As per Claim 4, the rejection of Claim 1 is incorporated; and Qin discloses “the original component corresponding to the target logic code file (paragraph [n0005], “According to one aspect of this disclosure, a method for updating a page component is provided, comprising: in response to running the page component, obtaining a first component instance [original component] of the page component, […] and in response to detecting that the page component has been updated, updating the first component instance based on the first mapping relationship (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above.”),” “the target component corresponding to the target logic code file (paragraph [n0060], “The reload function first iterates through the mapping list to get all the component instances corresponding to the San component, and then updates these component instances. That is, based on the updated San component, it gets the updated second component instance [target component] to replace the first component instance before the update (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above.”),” and “replacing a component instance of the original component corresponding to the target logic code file with a component instance of the target component corresponding to the target logic code file (paragraph [n0057], “According to some embodiments, the hot update plugin may further include a reload function, wherein updating the first component instance includes: in response to detecting that the page component has been updated, obtaining the first component instance to be updated based on the first mapping relationship […] obtaining a second component instance based on the reload function to replace the first component instance […] (emphasis added).”),” but the combination of Qin, Li, and Wang 01 does not explicitly disclose:
replacing component logic of the original component corresponding to the target logic code file with component logic of the target component corresponding to the target logic code file.
However, Wang 02 discloses:
replacing [data object] logic of the original [data object] with [data object] logic of the target component (paragraph [0093], “By replacing the function prototype of the first data object with the target function prototype, the replacement module 32 can replace the function logic of the first data object with the function logic of the second data object, thereby updating the first data object.”).
Wang 02 is within the same field of endeavor as the claimed invention regarding hot updates.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Wang 02 into the combined teachings of Qin, Li, and Wang 01 to include “replacing component logic of the original component corresponding to the target logic code file with component logic of the target component corresponding to the target logic code file.” The modification would be obvious because one of ordinary skill in the art would be motivated to replace component/function logic of the original component with the component/function logic of the target component in order to ensure the component behaves consistently with the updated logic. Moreover, updating the logic by replacing the function prototype corresponding to the component allows improved performance of hot updates to be achieved for data objects that have been loaded into memory or registered to other layers without needing to process each component separately (Wang 02, paragraph [0094]).
Claim 13 is an electronic device claim corresponding to method Claim 4 and is rejected for the same reasons as given in the rejection of that claim.
Claims 5-6 and 14-15 are rejected under 35 U.S.C. 103 as being unpatentable over Qin in view of Li, Wang 01, and Wang 02 as applied to Claims 4 and 13 above, and further in view of US 2014/0181788 (hereinafter “Sullivan”).
As per Claim 5, the rejection of Claim 4 is incorporated; and Qin discloses “obtaining the component instance corresponding to the original component from the logic code file of the target [application] (paragraph [n0057], “According to some embodiments, the hot update plugin may further include a reload function, wherein updating the first component instance includes: in response to detecting that the page component has been updated, obtaining the first component instance to be updated based on the first mapping relationship […] (emphasis added).”),” “the target component corresponding to the target logic code file (paragraph [n0060], “The reload function first iterates through the mapping list to get all the component instances corresponding to the San component, and then updates these component instances. That is, based on the updated San component, it gets the updated second component instance [target component] to replace the first component instance before the update (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above.”),” and “replacing the component instance corresponding to the original component with the component instance of the target component (paragraph [n0057], “[…] obtaining a second component instance based on the reload function to replace the first component instance […].”),” but the combination of Qin, Wang 01, and Wang 02 does not explicitly disclose:
obtaining the component instance corresponding to the original component from the logic code file of the target subroutine;
constructing the component instance corresponding to the target component based on a component attribute of the target component corresponding to the target logic code file.
However, Li discloses:
target subroutine (page 4, “MiniApp is a new format of mobile application […].”; page 5, “A miniapp can be distributed to multiple MiniApp platforms (the Web, a Native App, even the OS). These platforms also provide entry to the miniapp to ensure it can be easily discovered by the users.”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Li into the combined teachings of Qin, Wang 01, and Wang 02 to include “obtaining the component instance corresponding to the original component from the logic code file of the target subroutine.” The modification would be obvious because one of ordinary skill in the art would be motivated to utilize a MiniApp (subroutine) since it separates the View Layer (rendering pages) and Logic Layer (event processing) which is handy for data sharing and interaction among multiple MiniApp pages and can also help prevent JS execution impacting/slowing down page rendering which enhances the performance of rendering (Li, pages 9-10).
The combination of Qin, Li, Wang 01, and Wang 02 does not explicitly disclose:
constructing the component instance corresponding to the target component based on a component attribute of the target component corresponding to the target logic code file.
However, Sullivan discloses:
constructing the component instance corresponding to the target component based on a component attribute of the target component (paragraph [0118], “Furthermore, a dynamic component characterizes the UI component and facilitates dynamic construction of the UI component at runtime based on attributes and functionality specified via the dynamic component.”).
Sullivan is within the same field of endeavor as the claimed invention regarding constructing UI components.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Sullivan into the combined teachings of Qin, Li, Wang 01, and Wang 02 to include “constructing the component instance corresponding to the target component based on a component attribute of the target component corresponding to the target logic code file.” The modification would be obvious because one of ordinary skill in the art would be motivated to dynamically construct component instances based on attributes in order to effectively facilitate dynamic runtime adjustment of user interface display screens and accompanying components in response to data model changes (Sullivan, paragraphs [0016, 0038, & 0118]).
As per Claim 6, the rejection of Claim 5 is incorporated; and Qin discloses “constructing a mapping relationship set corresponding to the target component based on an association relationship between an attribute and an attribute value of the target component corresponding to the target logic code file (paragraph [n0054], “In some embodiments, a component identifier can be generated for the San component based on the createRecord function provided in the Vite hot update plugin, and the mapping relationship between the component instance and the component can be recorded based on the component identifier.”; paragraph [n0053], “In some embodiments, the mapping relationship may be recorded in a mapping relationship list.”),” but the combination of Qin, Li, Wang 01, and Wang 02 does not explicitly disclose:
constructing the component instance corresponding to the target component based on the mapping relationship set.
However, Sullivan discloses:
constructing the component instance corresponding to the target component based on [attributes] (paragraph [0118], “Furthermore, a dynamic component characterizes the UI component and facilitates dynamic construction of the UI component at runtime based on attributes and functionality specified via the dynamic component.”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Sullivan into the combined teachings of Qin, Li, Wang 01, and Wang 02 to include “constructing the component instance corresponding to the target component based on the mapping relationship set.” The modification would be obvious because one of ordinary skill in the art would be motivated to dynamically construct component instances based on attributes in order to effectively facilitate dynamic runtime adjustment of user interface display screens and accompanying components in response to data model changes (Sullivan, paragraphs [0016, 0038, & 0118]).
Claims 14 and 15 are electronic device claims corresponding to method Claims 5 and 6 respectively and are rejected for the same reasons as given in the rejection of those claims.
Claims 8 and 17 are rejected under 35 U.S.C. 103 as being unpatentable over Qin in view of Li and Wang 01 as applied to Claims 7 and 16 above, and further in view of US 2018/0088930 (hereinafter “Nelson”).
As per Claim 8, the rejection of Claim 7 is incorporated; and Qin discloses “if the target logic code file is the [ingress logic code file], to hot update the target page corresponding to the target logic code file (paragraph [n0056], “For example, when a developer re-edits the San file [target logic code file] and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”; paragraph [n0050], “For a San file, the first step is to parse the San file to generate a syntax tree […] By traversing the syntax tree, the defineComponent function used to define the San component, as well as the attached and detached lifecycle functions of the component, are obtained […].”; paragraph [n0052], “The attached lifecycle function is used to attach the component instance generated by the San component to the page when the page loads […].”),” but the combination of Qin and Wang 01 does not explicitly disclose:
invoking an update application code interface in a basic library if the target logic code file is the page ingress logic code file, to hot update the target page corresponding to the target logic code file; or
invoking an update application code interface in a basic library if the target logic code file is the non-page ingress logic code file, to hot update a page that depends on the target logic code file.
However, Li discloses:
page ingress logic code file (pages 10-11, “A MiniApp package is a compressed format (e.g. zip) archive, including: […] one or more multi page files, containing template codes for page structure, CSS codes for page style, and JavaScript codes for page logic.”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Li into the combined teachings of Qin, Wang 01, and Wang 02 to include “if the target logic code file is the page ingress logic code file, to hot update the target page corresponding to the target logic code file.” The modification would be obvious because one of ordinary skill in the art would be motivated to utilize a page file from a MiniApp since, after downloading/installing a MiniApp package, the page files exist on users’ machines and are always available without any redundant downloads until the next update. Moreover, utilizing a MiniApp with page files improves performance by providing multiple webviews (Li, pages 4 & 10).
The combination of Qin, Li, Wang 01, and Wang 02 does not explicitly disclose:
invoking an update application code interface in a basic library if the target logic code file is the page ingress logic code file, to hot update the target page corresponding to the target logic code file; or
invoking an update application code interface in a basic library if the target logic code file is the non-page ingress logic code file, to hot update a page that depends on the target logic code file.
However, Nelson discloses:
invoking an update application code interface in a basic library to [update code] (paragraph [0034], “If so, the application 233 can be instrumented to invoke an API call associated with the software library 273 that determines whether the updateable code 239 should be updated. In one embodiment, the software library 273 can generate an update request 241 that provides a version of the updateable code 239.”; abstract, “Updateable code can be updated upon launch of the application and/or upon invocation of a call associated with the software library.”).
Nelson is within the same field of endeavor as the claimed invention regarding invoking calls to update application code.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Nelson into the combined teachings of Qin, Li, Wang 01, and Wang 02 to include “invoking an update application code interface in a basic library if the target logic code file is the page ingress logic code file, to hot update the target page corresponding to the target logic code file.” The modification would be obvious because one of ordinary skill in the art would be motivated to utilize a system that invokes a call associated with a library to update code in order to help in allow the updating of content and/or logic that is employed by a software library that is bundled with an application without requiring the generation of a new binary associated with the application (Nelson, paragraph [0012]).
Claim 17 is an electronic device claim corresponding to method Claim 8 and is rejected for the same reasons as given in the rejection of that claim.
Claims 9 and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Qin in view of Li and Wang 01 as applied to Claims 1 and 10 above, and further in view of “Enable Hot Reloading in React Native” (hereinafter “Skptricks”) and US 2014/0189879 (hereinafter “Ruan”).
As per Claim 9, the rejection of Claim 1 is incorporated; and Qin discloses “wherein the modification operation is implemented using a developer tool (paragraph [n0006], “According to another aspect of this disclosure, a page component updating apparatus [developer tool] is provided, comprising: an acquisition unit configured to acquire a first component instance of the page component in response to running the page component, wherein the page component includes a hot-update plugin […] (emphasis added).”; paragraph [n0060], “In some embodiments, in response to the callback function import.meta.hot.accept being triggered, that is, when the San component is detected to be updated, the reload function will be triggered through the callback function, and the updated San component will be transmitted to the reload function (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”)” “the target logic code file (paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”),” and “[…] in response to a determination that the logic code file of the target [application] changes (paragraph [n0060], “In some embodiments, in response to the callback function import.meta.hot.accept being triggered, that is, when the San component is detected to be updated, the reload function will be triggered through the callback function, and the updated San component will be transmitted to the reload function (emphasis added).”; paragraph [n0056], “For example, when a developer re-edits the San file and clicks save, the callback function will be triggered, and then each component instance will be updated accordingly based on the mapping relationship between the components and component instances mentioned above (emphasis added).”),” but the combination of Qin and Wang 01 does not explicitly disclose:
when a switch for automatic hot reload in the developer tool is turned on:
determining a type of the target logic code file in response to a determination that the logic code file of the target subroutine changes, wherein the type comprises: an ingress logic code file of the target subroutine, the page ingress logic code file, and the non-page ingress logic code file.
However, Li discloses:
target subroutine (page 4, “MiniApp is a new format of mobile application […].”; page 5, “A miniapp can be distributed to multiple MiniApp platforms (the Web, a Native App, even the OS). These platforms also provide entry to the miniapp to ensure it can be easily discovered by the users.”);
wherein the type comprises: an ingress logic code file of the target subroutine, the page ingress logic code file, and the non-page ingress logic code file (pages 10-11, “A MiniApp package is a compressed format (e.g. zip) archive, including: one configuration document, located at the root directory of the package […] one app-level logic file, containing JavaScript codes, deals with app-level lifecycle callbacks. one or more multi page files, containing template codes for page structure, CSS codes for page style, and JavaScript codes for page logic.”).
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Li into the combined teachings of Qin and Wang 01 to include “[…] in response to a determination that the logic code file of the target subroutine changes; wherein the type comprises: an ingress logic code file of the target subroutine, the page ingress logic code file, and the non-page ingress logic code file.” The modification would be obvious because one of ordinary skill in the art would be motivated to utilize a MiniApp (subroutine), which contains ingress, page ingress, and non-page ingress logic code files, since the MiniApp separates the View Layer (rendering pages) and Logic Layer (event processing) which is handy for data sharing and interaction among multiple MiniApp pages and can also help prevent JS execution impacting/slowing down page rendering which enhances the performance of rendering (Li, pages 9-10).
The combination of Qin, Li, and Wang 01 does not explicitly disclose:
when a switch for automatic hot reload in the developer tool is turned on:
determining a type of the target logic code file in response to a determination that the logic code file of the target subroutine changes, wherein the type comprises: an ingress logic code file of the target subroutine, the page ingress logic code file, and the non-page ingress logic code file.
However, Skptricks discloses:
when a switch for automatic hot reload in the developer tool is turned on […]
PNG
media_image1.png
1112
1472
media_image1.png
Greyscale
[Examiner’s Remarks: Note that there is a “Disable Hot Reloading” button on the screen of the phone which shows that automatic hot reloads are enabled. This button/switch highlights the functionality of a user enabling/disabling automatic hot reloads. For a better understanding, please refer to 1:08-1:25 of the Youtube video.].
Skptricks is within the same field of endeavor as the claimed invention regarding automatic hot reloads.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Skptricks into the combined teachings of Qin, Li, and Wang 01 to include “when a switch for automatic hot reload in the developer tool is turned on.” The modification would be obvious because one of ordinary skill in the art would be motivated to provide a switch for automatic hot reload in order to ensure the user has the option to enable/disable hot reload whenever desired and effectively allow hot reloading to occur without manual intervention when automatic hot reload is enabled which saves developer effort (Skptricks, 1:08-1:25).
The combination of Qin, Li, Wang 01, and Skptricks does not explicitly disclose:
determining a type of the target logic code file in response to a determination that the logic code file of the target subroutine changes, wherein the type comprises: an ingress logic code file of the target subroutine, the page ingress logic code file, and the non-page ingress logic code file.
However, Ruan discloses:
determining a type of the [file] in response to a determination that the [file] changes (abstract, “A method for identifying a file type and an apparatus for identifying a file type, so as to solve a problem in the prior art that a file type cannot be effectively identified when a sender tampers with a file being transmitted.”; paragraph [0015], “[…] determining that a file type of the file to be identified is an abnormal type, where the abnormal type is used to indicate that the file to be identified is a file whose type has been tampered [changed] with (emphasis added).”).
Ruan is in the same field of endeavor as the claimed invention regarding the detection of file types and file-related changes.
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Ruan into the combined teachings of Qin, Li, Wang 01, and Skptricks to include “determining a type of the target logic code file in response to a determination that the logic code file of the target subroutine changes.” The modification would be obvious because one of ordinary skill in the art would be motivated to determine a type of a modified file in order to effectively identify when a file has been tampered with which helps improve information security (Ruan, abstract & paragraph [0003]).
Claim 18 is an electronic device claim corresponding to method Claim 9 and is rejected for the same reasons as given in the rejection of that claim.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to Feven H. Huruy whose telephone number is (571) 272-3826. The examiner can normally be reached Mon-Fri. 7:30am-3:45pm.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Mui can be reached at (571) 272-3708. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/F.H.H./Examiner, Art Unit 2191 /WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191
Prosecution Insights