CN111666199B - Debugging method executed on intelligent terminal and software debugger - Google Patents
Debugging method executed on intelligent terminal and software debugger Download PDFInfo
- Publication number
- CN111666199B CN111666199B CN201910163934.XA CN201910163934A CN111666199B CN 111666199 B CN111666199 B CN 111666199B CN 201910163934 A CN201910163934 A CN 201910163934A CN 111666199 B CN111666199 B CN 111666199B
- Authority
- CN
- China
- Prior art keywords
- debugging
- information
- page
- tested
- intercepting
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3628—Software debugging of optimised code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
Abstract
The invention provides a debugging method executed on an intelligent terminal, which comprises the steps of intercepting an interface call initiated by a page to be tested and acquiring first information for debugging when the interface call is initiated; after the first information is acquired, executing the interface call; intercepting a response to the interface call and acquiring second information for debugging; and executing the response to the page to be tested after the second information is acquired. The invention also provides a software debugger, a computer storage medium and an intelligent terminal.
Description
Technical Field
The present invention relates to the field of software debugging, and in particular, to a debugging method (i.e., real machine development and debugging) executed on an intelligent terminal, a software debugger, a computer storage medium, and an intelligent terminal.
Background
With the rise of mobile wave, various APP applications emerge endlessly, and the requirement of a team on development efficiency is improved by extremely rapid business expansion. H5 (i.e., HTML 5) is an advanced web technology that is utilized to form a hybrid APP development model due to its low cost, high efficiency, cross-platform, etc. features. In this hybrid development mode, the program developer writes pure H5 code and finally loads the rendering through the Webview component of the native side.
The hybrid development mode is very beneficial to front-end access and is suitable for quick service iteration, but because the APP page runs in the client Webview framework, the compatibility problem exists due to different platforms and manufacturers. However, the existing debugging method only depends on means such as testing, code checking and user feedback, and can not comprehensively find and locate the compatibility problems. Moreover, the existing debugging method also has certain requirements on the development environment, for example, a configuration file needs to be downloaded from a google server, a special debug version needs to be packaged by a client, and the like, which further aggravates the problems of difficult positioning and difficult development and debugging.
The above information disclosed in this background section is only for enhancement of understanding of the general background of the invention and should not be taken as an acknowledgement or any form of suggestion that this information forms the prior art already known to a person skilled in the art.
Disclosure of Invention
The invention provides a solution for development and debugging of a real machine, which solves the problems of difficult positioning and difficult development and debugging by page debugging in the real machine.
According to an aspect of the present invention, there is provided a debugging method performed on an intelligent terminal, the method including: when an interface call initiated by a page to be tested is called, intercepting the interface call and acquiring first information for debugging; after the first information is acquired, executing the interface call; intercepting a response to the interface call and acquiring second information for debugging; and executing the response to the page to be tested after the second information is acquired.
Optionally, the debugging method further includes: and classifying and converting the first information and the second information into a standard json data format.
Optionally, in the debugging method, the page to be tested is an H5 page.
Optionally, in the debugging method, the interface call includes a client plug-in function and a background interface message request.
Optionally, the debugging method further includes: and injecting a self-executable debugging file after the page to be tested is loaded, so that an entrance of a debugging panel appears in the page to be tested.
Optionally, the debugging method further includes: the debug file is dynamically introduced by configuring the debug identification in the code provided to the third party access.
Optionally, in the above debugging method, the debugging file is a js file.
Optionally, in the debugging method, intercepting the request or the response of the interface call is implemented by performing interception rewriting on the native method of the client plug-in.
Optionally, in the debugging method, the intercepting rewrite includes: deeply copying a prokaryotic core function of the client plug-in; periodically polling whether the prokaryotic core function is in a rewritable state; if so, the prokaryotic core function is rewritten to produce a second core function that is capable of both collecting information for debugging and performing the functions of the prokaryotic core function.
According to another aspect of the present invention, there is provided a software debugger, including: the device comprises a first interception device, a second interception device and a third interception device, wherein the first interception device is used for intercepting an interface call initiated by a page to be tested and acquiring first information for debugging; the first execution device is used for executing the interface call after the first information is acquired; the second interception device is used for intercepting the response to the interface call and acquiring second information for debugging; and the second execution device is used for executing the response to the page to be tested after the second information is acquired.
Optionally, the software debugger further includes: and the conversion device is used for converting the first information and the second information into a standard json data format in a classified mode.
Optionally, in the software debugger, the page to be tested is an H5 page.
Optionally, in the software debugger, the interface call includes a client plug-in function and a background interface message request.
Optionally, the software debugger further includes: and the injection device is used for injecting a self-executable debugging file after the page to be tested is loaded, so that an entrance of a debugging panel appears in the page to be tested.
Optionally, the software debugger further includes: and the introducing device is used for dynamically introducing the debugging file by configuring the debugging identification in the code provided for the third party to access.
Optionally, in the software debugger, the debug file is a js file.
Optionally, in the software debugger, the first intercepting means and the second intercepting means are implemented based on intercepting rewriting of the client plug-in native method.
Optionally, in the software debugger, the intercepting the rewrite includes: deeply copying a prokaryotic core function of the client plug-in; periodically polling whether the prokaryotic core function is in a rewritable state; if so, the prokaryotic core function is rewritten to produce a second core function that is capable of both collecting information for debugging and performing the functions of the prokaryotic core function.
According to yet another aspect of the invention, there is provided a computer storage medium comprising instructions which, when executed, perform a debugging method as previously described.
According to a further aspect of the present invention, there is provided an intelligent terminal including the software debugger as described above.
According to the technical scheme, the interface call and the response of the client plug-in to the interface call are intercepted and obtained, so that a developer can see the system information, the page message content and the calling execution condition of the client plug-in real time under a real machine environment, and the developer is facilitated to locate problems and correspondingly debug codes.
Other features and advantages of the methods and apparatus of the present invention will be more particularly apparent from or elucidated with reference to the drawings described herein, and the following detailed description of the embodiments used to illustrate certain principles of the invention.
Drawings
FIG. 1 is a flow diagram illustrating a debugging method performed on an intelligent terminal according to one embodiment of the invention;
FIG. 2 is a block diagram illustrating a software debugger of an embodiment of the present invention; and
FIG. 3 is an interaction diagram illustrating a debugging method according to an embodiment of the present invention.
Detailed Description
The following description describes specific embodiments of the invention to teach those skilled in the art how to make and use the best mode of the invention. For the purpose of teaching inventive principles, some conventional aspects have been simplified or omitted. Those skilled in the art will appreciate variations from these embodiments that will fall within the scope of the invention. Those skilled in the art will appreciate that the features described below can be combined in various ways to form multiple variations of the invention. Thus, the present invention is not limited to the specific embodiments described below, but only by the claims and their equivalents.
In the context of the present invention, the terms "Hybrid APP", "Hybrid APP development" or "Hybrid application development" refer to Hybrid mobile application development combined with Native through Web network technologies (such as HTML, CSS and Javascript).
The term "Cordova" denotes a mobile development framework that provides a set of device-related APIs through which mobile applications can access native device functionality, such as cameras, microphones, etc., in JavaScript. Cordova supports a variety of mobile operating systems, including IOS, Android, Blackberry, and the like.
The term "Webview" refers to a client's browsing control/component that internally employs a rendering engine to display page content. Webview can load and display web pages, pictures, etc., which can be viewed as a browser.
Referring to fig. 1, a flow diagram 1000 of a debugging method performed on an intelligent terminal according to one embodiment of the invention is shown. In the context of the present invention, the term "smart terminal" includes mobile devices, such as cell phones.
As shown in fig. 1, a debugging method 1000 executed on an intelligent terminal includes: a1, intercepting an interface call initiated by a page to be tested and acquiring first information for debugging when the interface call is initiated; step A2, after the first information is obtained, executing the interface call; step A3, intercepting a response (for example, a client plug-in) to the interface call, and acquiring second information for debugging; and step A4, after the second information is obtained, executing the response to the page to be tested.
In one embodiment, the first information and the second information for debugging may include: url (uniform resource locator), method (request method), PluginName (Cordova plug-in name), actionName (Cordova plug-in action function name), params (request parameter), status (response status), responseType, responseHeaders (response header information), response (response data), startTime (call start time), endTime (response end time), costTime (time elapsed between call start and response end).
Preferably, the debugging method 1000 may further include: step a5, converting the first information and the second information into a standard json data format for display, for example.
In one embodiment, the page to be tested is an H5 page. In one embodiment, the interface call includes a client plug-in function and a background interface message request.
Although not shown in fig. 1, in one embodiment, the debugging method 1000 further comprises: step B1, before step A1, injects a self-executable debug file at or after completion of, for example, Webview loading the page to be tested. In one embodiment, the aforementioned debug file may be a js file. For example, in the client debug version, a self-executable local js file is provided, which is injected after the webview load page triggers a finish event, so that the debug panel entry is visible in the H5 page.
In another embodiment, the debugging method 1000 further includes: step B2: before step a1, a debug file is dynamically introduced by configuring a debug identification in code provided to third party access. In one embodiment, the aforementioned debug file may be a js file. For example, in the upsdk. js code provided for third party access, the debug panel js file is dynamically introduced by debug identification configuration.
By the debugging method at the intelligent terminal side, a developer can see system information, page message content and calling execution conditions of the client plug-in real time under a real machine environment when adopting a hybrid development mode of Hrybridge + H5. This facilitates the developer to locate problems and thus perform code debugging.
It will be understood by those skilled in the art that all or part of the steps in the method of one or more of the above embodiments may be implemented by instructing hardware associated with the terminal device through a program, where the program may be stored in a computer-readable storage medium, and the storage medium may include: flash memory, read only memory, random access memory, magnetic or optical disks, and the like.
FIG. 2 is a block diagram illustrating a software debugger of an embodiment of the present invention. As shown in fig. 2, software debugger 2000 includes: a first interception device 210, a first execution device 220, a second interception device 230, and a second execution device 240. The first intercepting device 210 is configured to intercept an interface call initiated by a page to be tested and obtain first information for debugging when the interface call is initiated. The first executing device 220 is configured to execute the interface call after acquiring the first information. The second intercepting means 230 is configured to intercept a response to the interface call and obtain second information for debugging. The second executing device 240 is configured to execute the response to the page to be tested after acquiring the second information.
Although not shown in FIG. 2, in one embodiment, software debugger 2000 described above may also include a translation device. The conversion means is arranged to convert said first information and said second information into a standard json data format for presentation, for example.
In one embodiment, in the software debugger, the page to be tested is an H5 page, and the interface call includes a client plug-in function and a background interface message request.
In one embodiment, the software debugger further includes: and the injection device is used for injecting a debugging file (such as a js file) when the Webview finishes loading the page to be tested. Optionally, the software debugger includes: and the introducing device is used for dynamically introducing a debugging file (such as a js file) in the code provided for the third party to access by configuring the debugging identifier.
The software debugger described above is merely illustrative, and for example, the division of the apparatus is only one division of logical functions, and there may be other divisions when actually implementing, for example, a plurality of apparatuses may be combined or may be integrated into another system.
FIG. 3 is an interaction diagram illustrating a debugging method according to an embodiment of the present invention. In the embodiment, the bottom layer function of the Cordova native code is rewritten, execution information of the Cordova is intercepted and obtained, and the execution information is displayed in different tab pages of the debugging panel after being classified and converted into a standard json data format.
Specifically, as shown in FIG. 3, Webview injects debug js after H5 page load is complete (loadFinish event is triggered). The debugging js implemented in the embodiment has a main function of intercepting a corresponding API (application program interface) method when an interface call (including a client plug-in function and a background interface message request) is initiated through cordiva/ajax in an H5 page, and the interception is divided into the following two steps:
1) intercepting when the H5 page initiates function/request call, and executing the original function/request call after acquiring information required by debugging;
2) and intercepting the API method for acquiring the function/request response in the H5 page, and executing the original function/request response after acquiring the information required by debugging.
After the interception is finished, the information which is collected in the step 1)2) and can be used for debugging is classified and converted into a standard json data format, and then the information is displayed in different tab pages of a debugging panel.
In one embodiment, the function/request call comprises: exec (execute function) of Cordova, open (open function) of ajax, and send (send function) of ajax.
In one embodiment, the function/request response comprises: cordova's success/failure callback function, ajax's onreadystatechange.
In one embodiment, the information available for debugging includes: url (uniform resource locator), method (request method), PluginName (Cordova plug-in name), actionName (Cordova plug-in action function name), params (request parameter), status (response status), responseType, responseHeaders (response header information), response (response data), startTime (call start time), endTime (response end time), costTime (time elapsed between call start and response end).
The embodiment of the invention is different from the existing mode of acting by using protocols such as http or websocket, and adopts a form of rewriting a core method or a function. Particularly for the interception rewriting of the cordiva plug-in native method, the specific implementation form can be as follows:
1. memory core method or function coreFunc
oldFunc = coreFunc// object deep copy, so that normal execution of subsequent requests is not affected
2. The timed polling determines whether the original core method oldFunc is in a state that can be rewritten and whether the context is ready.
3. Rewriting core methods or functions
coreFunc = newFunc
The newFunc role includes (a) collecting debug information and (b) executing a prokaryotic core method or function oldFunc.
Compared with the prior art that only some contents related to webpage technologies (such as the H5 technology) can be debugged, the embodiment of the present invention can also debug the messages sent by the client plug-in or the contents realized by the client function in the hybrid APP development mode using H5.
It will be appreciated by one of ordinary skill in the art that one or more of the embodiments described above may be embodied in the form of a software product stored on a storage medium and including instructions for causing one or more computing devices (which may be personal computers, servers, network devices, etc.) to perform all or a portion of the steps of the method.
The above examples mainly illustrate the debugging method, software debugger, computer storage medium and intelligent terminal of the present invention executed on the intelligent terminal. Although only a few embodiments of the present invention have been described in detail, those skilled in the art will appreciate that the present invention may be embodied in many other forms without departing from the spirit or scope thereof. Accordingly, the present examples and embodiments are to be considered as illustrative and not restrictive, and various modifications and substitutions may be made therein without departing from the spirit and scope of the present invention as defined by the appended claims.
Claims (12)
1. A debugging method executed on an intelligent terminal is characterized by comprising the following steps:
step B1: after loading a page to be tested by the Webview component, injecting a self-executable debugging file by configuring a debugging identifier, so that an entrance of a debugging panel appears in the page to be tested;
step A1: when an interface call initiated by a page to be tested is called, intercepting the interface call and acquiring first information for debugging;
step A2: after the first information is acquired, executing the interface call;
step A3: intercepting a response to the interface call and acquiring second information for debugging; and
step A4: after the second information is obtained, executing the response to the page to be tested,
intercepting the request or the response of the interface call is realized by intercepting and rewriting a native method of a Cordova plug-in, wherein the intercepting and rewriting comprises the following steps:
deep copying a prokaryotic core function of a Cordova plug-in;
periodically polling whether the prokaryotic core function is in a rewritable state;
if so, the prokaryotic core function is rewritten to produce a second core function that is capable of both collecting information for debugging and performing the functions of the prokaryotic core function.
2. A debugging method in accordance with claim 1, further comprising:
step A5: and classifying and converting the first information and the second information into a standard json data format.
3. The method of claim 1, wherein the page to be tested is an H5 page.
4. The method of claim 1, wherein the interface call comprises a client plug-in function and a background interface message request.
5. The method of claim 1, wherein the debug file is a js file.
6. A software debugger, the software debugger comprising:
the injection device is used for injecting a self-executable debugging file by configuring a debugging identifier through the introduction device after the Webview component finishes loading the page to be tested, so that an entrance of a debugging panel appears in the page to be tested;
the device comprises a first interception device, a second interception device and a third interception device, wherein the first interception device is used for intercepting an interface call initiated by a page to be tested and acquiring first information for debugging;
the first execution device is used for executing the interface call after the first information is acquired;
the second interception device is used for intercepting the response to the interface call and acquiring second information for debugging; and
a second executing device for executing the response to the page to be tested after the second information is acquired,
wherein the first and second intercepting devices are implemented based on intercepting and rewriting a Cordova plug-in native method, and the intercepting and rewriting includes:
deep copying a prokaryotic core function of a Cordova plug-in;
periodically polling whether the prokaryotic core function is in a rewritable state;
if so, the prokaryotic core function is rewritten to produce a second core function that is capable of both collecting information for debugging and performing the functions of the prokaryotic core function.
7. The software debugger of claim 6, further comprising:
and the conversion device is used for converting the first information and the second information into a standard json data format in a classified mode.
8. The software debugger of claim 6, wherein the page to be tested is an H5 page.
9. The software debugger of claim 6, wherein the interface call comprises a client plug-in function and a background interface message request.
10. The software debugger of claim 6, wherein the debug file is a js file.
11. A computer storage medium comprising instructions that, when executed, perform the method of any of claims 1 to 5.
12. An intelligent terminal comprising a software debugger according to any of claims 6 to 10.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910163934.XA CN111666199B (en) | 2019-03-05 | 2019-03-05 | Debugging method executed on intelligent terminal and software debugger |
| PCT/CN2020/075524 WO2020177519A1 (en) | 2019-03-05 | 2020-02-17 | Debugging method executed on smart terminal and software debugging device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910163934.XA CN111666199B (en) | 2019-03-05 | 2019-03-05 | Debugging method executed on intelligent terminal and software debugger |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111666199A CN111666199A (en) | 2020-09-15 |
| CN111666199B true CN111666199B (en) | 2022-01-11 |
Family
ID=72336884
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910163934.XA Active CN111666199B (en) | 2019-03-05 | 2019-03-05 | Debugging method executed on intelligent terminal and software debugger |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN111666199B (en) |
| WO (1) | WO2020177519A1 (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113641581B (en) * | 2021-08-11 | 2023-10-20 | 上海哔哩哔哩科技有限公司 | Mixed mode mobile application debugging method and system |
| CN113641580B (en) * | 2021-08-11 | 2023-10-20 | 上海哔哩哔哩科技有限公司 | Mixed mode mobile application debugging method and system |
| CN113836460B (en) * | 2021-08-13 | 2022-05-27 | 深圳市明源云空间电子商务有限公司 | mock data control method, equipment terminal and computer readable storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106055480A (en) * | 2016-06-02 | 2016-10-26 | 腾讯科技（深圳）有限公司 | Webpage debugging method and terminal |
| CN106598830A (en) * | 2015-10-16 | 2017-04-26 | 阿里巴巴集团控股有限公司 | Mobile terminal webpage script debugging method and system |
| CN108345535A (en) * | 2017-12-26 | 2018-07-31 | 阿里巴巴集团控股有限公司 | Mock test methods, device and equipment |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102981947B (en) * | 2011-09-07 | 2015-07-08 | 阿里巴巴集团控股有限公司 | Data preparation method in test and system provided with the same |
| KR20140095882A (en) * | 2013-01-25 | 2014-08-04 | 삼성전자주식회사 | Test system for evaluating mobile device and driving method thereof |
| CN105354143A (en) * | 2015-12-02 | 2016-02-24 | 北京奇虎科技有限公司 | Test method and device for application programs |
| US20180165177A1 (en) * | 2016-12-08 | 2018-06-14 | Nutanix, Inc. | Debugging distributed web service requests |
-
2019
- 2019-03-05 CN CN201910163934.XA patent/CN111666199B/en active Active
-
2020
- 2020-02-17 WO PCT/CN2020/075524 patent/WO2020177519A1/en active Application Filing
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106598830A (en) * | 2015-10-16 | 2017-04-26 | 阿里巴巴集团控股有限公司 | Mobile terminal webpage script debugging method and system |
| CN106055480A (en) * | 2016-06-02 | 2016-10-26 | 腾讯科技（深圳）有限公司 | Webpage debugging method and terminal |
| CN108345535A (en) * | 2017-12-26 | 2018-07-31 | 阿里巴巴集团控股有限公司 | Mock test methods, device and equipment |
Non-Patent Citations (3)
| Title |
|---|
| "axios拦截器";hupei;《https://hupeip.github.io/2018/10/08/axios拦截器/》;20181008;第1-5页 * |
| "network.js";Maizify等;《https://github.com/Tencent/vConsole/releases/tag/v3.2.0》;20180410;第1-11页 * |
| "vConsole预研";maxiao;《https://maxlao.com/vconsoleyu-yan/》;20180817;第1-18页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111666199A (en) | 2020-09-15 |
| WO2020177519A1 (en) | 2020-09-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107133180B (en) | Dynamic page testing method, testing device and storage medium | |
| US9342237B2 (en) | Automated testing of gesture-based applications | |
| CN107688529B (en) | Component debugging method and device | |
| CN111666199B (en) | Debugging method executed on intelligent terminal and software debugger | |
| CN110808897A (en) | Proxy access method, user equipment, storage medium, device and system | |
| CN104821954A (en) | Cross-platform remote procedure call method | |
| CN109873735B (en) | Performance test method and device for H5 page and computer equipment | |
| CN109344066B (en) | Method, system and terminal for testing browser page | |
| GB2589658A (en) | Method and apparatus for running an applet | |
| CN107045475B (en) | Test method and device | |
| CN110955589A (en) | Method, system, device and medium for testing headless mode based on browser | |
| CN110365724B (en) | Task processing method and device and electronic equipment | |
| CN107644075B (en) | Method and device for collecting page information | |
| CN110598135A (en) | Network request processing method and device, computer readable medium and electronic equipment | |
| US9760472B2 (en) | Tenant code debugging in multi-tenant systems | |
| CN106557411B (en) | Method and system for testing Hybrid application in Android system | |
| CN111949515A (en) | Test scene reproduction method and device and electronic equipment | |
| CN103488508B (en) | Browser working method, browser and terminal equipment | |
| CN107102937B (en) | User interface testing method and device | |
| CN112148395A (en) | Page display method, device, equipment and storage medium | |
| CN107239265B (en) | Binding method and device of Java function and C function | |
| CN111880789A (en) | Page rendering method, device, server and computer-readable storage medium | |
| CN107391354B (en) | Method and system for automatically monitoring terminal performance and storage device | |
| CN111338928A (en) | Chrome-based browser testing method and device | |
| CN116136772A (en) | Buried point data acquisition method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |