Add documentation for new features in tizen studio 6.0

docs/application/toc_all.md

@@ -1167,10 +1167,16 @@
 ## Visual Studio Code Extension for Tizen
 ### [Prerequisites](/application/vscode-ext/index.md)
 ### [Installing Visual Studio Code Extension for Tizen](/application/vscode-ext/Tizen/dotnet.md)
+### [Tizen Welcome Page](/application/vscode-ext/tools/welcome-page.md)
+### [Tizen Activity Bar](/application/vscode-ext/tools/activity-bar.md)
 ### Tools
 #### [Profiler](/application/vscode-ext/tools/profiler-user-manual.md)
 #### [Memory Profiler](/application/vscode-ext/tools/memory-profiler-user-manual.md)
-### Tizen
+#### [Address Sanitizer](/application/vscode-ext/tools/address-sanitizer-user-manual.md)
+#### [Leak Sanitizer](/application/vscode-ext/tools/leak-sanitizer-user-manual.md)
+#### [UTC and Code Coverage](/application/vscode-ext/tools/unit-test-code-coverage-user-manual.md)
+#### [Dotnet Diagnostics](/application/vscode-ext/tools/diagnostics.md)
+#### [Web Assembly](/application/vscode-ext/tools/wasm.md)
 #### [Hybrid application development](/application/vscode-ext/Tizen/hybrid.md)
 #### [RPK Application Development](/application/vscode-ext/Tizen/rpk.md)
 ### [Tizen Web](/application/vscode-ext/web.md)

docs/application/vscode-ext/Tizen/dotnet.md

@@ -15,7 +15,7 @@ To install VS Code Extension for Tizen from the Visual Studio Code Marketplace:
 2. In the **Extensions** view's **Search Extensions in Marketplace** field, enter **Tizen**.
 3. Locate **Visual Studio Code Extension for Tizen** in the search results and click **Install**.
 4. After the installation is complete, activate the extension by clicking **Reload**.
-5. Once the extension has been activated, it asks whether you want to use an existing Tizen Baseline SDK installation or install a new one:
+5. Once the extension has been activated, it asks whether you want to use an existing Tizen Baseline SDK installation or install a new one. Alternatively, you can use the GUI to perform the same task. Click [here](../tools/welcome-page.md#install-tizen-sdk) to access the GUI.
 
    ![Visual Studio Code Marketplace](media/vscode_baselinesdk_exists.png)
 

docs/application/vscode-ext/tools/activity-bar.md

@@ -0,0 +1,49 @@
+# Tizen Activity Bar and Sidebar Feature
+
+The new Tizen Activity Bar and Sidebar features offer a suite of powerful tools and functionalities designed to streamline your workflow, boost productivity, and make coding more intuitive than ever before. 
+
+The sidebar contains following features: [Welcome](#welcome-page), [Tizen Tools](#tizen-tools), [Actions](#actions), [Connected Devices](#connected-devices), [Report Platform Bug](#report-platform-bug)
+
+### Welcome Page
+   - Please refer to the [Welcome](welcome-page.md#open-welcome-page) Section for an introduction to the Tizen Extension for VS Code.
+
+![Activity Bar Contents](media/welcome-page2.png)
+
+### Tizen Tools
+   - The Tizen Tools section contains following tools for Tizen development: 
+
+     1. [**Tizen Emulator Manager**](../../tizen-studio/common-tools/emulator.md): The Tizen Emulator Manager allows you to create and manage emulator instances.
+
+     2. [**Device Manager**](../../tizen-studio/common-tools/device-manager.md): The Device Manager allows you to connect your device and manage it.
+
+     3. [**Certificate Manager**](../../tizen-studio/common-tools/certificate-registration.md): The Certificate Manager allows you to create and manage certificates.
+
+     4. [**Package Manager**](../../tizen-studio/setup/advanced-configuration.md): The Package Manager allows you to install, update, and remove Tizen Studio packages.
+
+
+     To **access these tools**, click on the **respective icons** in the **Tizen Tools section**. Each tool will open separately, providing you with the necessary functionalities for efficient Tizen development.
+
+### Actions
+   - The Actions section includes various **commands** to streamline your Tizen project workflow:
+
+     1. **New Project**: Initiates the creation of a new Tizen project.
+
+     2. **Build Project**: Compiles the source code and generates output of your Tizen project.
+
+     3. **Run Project**: Executes the built project on a target device or emulator.
+
+     4. **Debug Project**: Launches the Tizen project in debug mode, allowing you to set breakpoints and analyze the code execution.
+
+     5. **Open Profiler**: Opens the Tizen Profiler, which helps in analyzing performance metrics and optimizing your application.
+
+     **Click** on the desired **action** to perform the corresponding operation on your Tizen project.
+
+### Connected Devices
+   - The Connected Devices section displays a list of all connected Tizen devices. This allows you to select a specific device for running or debugging your Tizen project.
+
+   - To **view** the connected devices, **navigate** to the **Connected Devices** section.
+
+### Report Platform Bug
+   - If you encounter any **issues or bugs** while using the Tizen Extension for VS Code, you can use the **Report Platform Bug** feature to report them.
+
+   - To report a **bug**, click on the **Report Platform Bug** button and provide the necessary **details** about the issue you encountered.

docs/application/vscode-ext/tools/address-sanitizer-user-manual.md

@@ -0,0 +1,33 @@
+# Detecting Runtime Memory Errors with Address Sanitizer
+- The Address Sanitizer is a tool that helps find memory errors in Tizen native apps. It checks if certain parts of the code might cause memory problems while running. This tool can prevent crashes or bugs during app use. It works by adding extra code during app compilation. If the app doesn't crash with the Address Sanitizer, it means the code is safe from memory issues. The tool can find different types of bugs. The Address Sanitizer tool can detect the following types of bugs:
+
+- Out-of-bounds accesses to heap and stack
+- Use-after-free
+- Use-after-return (to some extent)
+- Double free and invalid free
+
+## Using Address Sanitizer
+- In the **Menu**, click on view and select **Command Palette > Tizen: Profile with Memory Errors**.
+
+  The profiling instruments the code and compiles the project for the Address Sanitizer. Finally, it launches the application on the connected target or emulator, as illustrated in the following figure.
+
+    ![Launch Command](media/launch_asan.png)
+    <br>
+
+- After the application is launched, run the application scenario you want to test
+- Visual studio code shows the profiling result after clicking on **Stop Profiling Button**.
+
+    ![Stop Profile Button](media/stop_profiling_button.png)
+    <br>
+
+- Once clicked on the **Stop Profiling Button**, application will crash if there are any errors hence the report will be generated and if there are no memory errors it will give the message no error found, as illustrated in the following figure.
+
+    ![Asan UI Report](media/failure_report.png)
+    <br>
+
+  ## Source File Navigation on Failure
+  - When a failure occurs, you can click on the **line number associated with the failure which is generated in UI Report**.
+  - This action will open the corresponding source file in your editor and **navigate to the exact location where the failure has occurred**, as illustrated in the following figure.
+
+
+    ![Failure occured](media/failure_line.png)                                                         

docs/application/vscode-ext/tools/diagnostics.md

@@ -0,0 +1,139 @@
+# Get Started with .NET Core Diagnostics
+
+.NET Core Diagnostics supports a number of tools that can be used to diagnose the Tizen .NET applications.
+It includes dotnet-gcdump, dotnet-dump, and dotnet-trace tools to aid .NET developers in diagnosing their applications.
+
+## Prerequisites
+
+Below are the prerequisites for using Tizen .NET Core Diagnostics in Visual Studio Code:
+
+- Make sure that Tizen Studio Version 6.0 or above is installed.
+- Make sure to set the Tizen Studio Path with the installed 6.0 or above Tizen Studio path using VS Code Command: **Tizen: Wizard to set Tizen Baseline SDK path or install a new.**.
+
+## Tizen .NET Core Diagnostics tools
+
+## dotnet-gcdump
+
+### Step 1. Run dotnet-gcdump tool
+   - If no Tizen device is connected and no Tizen emulators are running then launch the type of emulator you want to use for diagnosing your application.
+
+     ![Launch Emulator](media/start_emulator.png)
+
+   - Open the **Command Palette** and select **Tizen.NET: Run dotnet diagnostics tools**.
+
+     ![Run dotnet-gcdump](media/dotnet-diagnostics.png)
+
+   - Now select the **gcdump** from drop down list.
+
+     ![Select dotnet-gcdump](media/dotnet-gcdump-select.png)
+
+   - If everything is ok then the application starts and it starts collecting the gcdump file.
+
+     ![Tizen application running](media/dotnet-gcdump-running.png)
+
+
+   - Once the gcdump file is collected, a message popup is shown to inform the user, and the file is added to the **gcdump** folder inside the **TizenDiagnostics** folder of the project.
+
+     ![Completed dotnet-gcdump](media/dotnet-gcdump-completed.png)
+
+
+
+
+### Step 2. Analyze the gcdump file
+   - Once the gcdump file is collected, a message popup is shown with the option to open the generated gcdump file. Once we click the **YES** option. It will open the file in **PerfView** tool.
+     ![gcdump PerfView analysis view](media/dotnet-gcdump-perfview.png)
+
+  - Another way to open the **gcdump** file is to right click the gcdump file in **File Explorer Panel** of VS Code and select **Tizen: Open in Diagnostics File Viewer**. It will open the file in **PerfView** tool.
+     ![gcdump PerfView analysis view](media/dotnet-gcdump-open.png)
+
+  - **NOTE: Above two options to open/view gcdump file is supported only in Windows OS.**
+
+
+## dotnet-trace
+
+### Step 1. Run dotnet-trace tool
+   - If no Tizen device is connected and no Tizen emulators are running then launch the type of emulator you want to use for diagnosing your application.
+
+     ![Launch Emulator](media/start_emulator.png)
+
+   - Open the **Command Palette** and select **Tizen.NET: Run dotnet diagnostics tools**.
+
+     ![Run dotnet-trace](media/dotnet-diagnostics.png)
+
+   - Now select the **trace** from drop down list.
+
+     ![Select dotnet-trace](media/dotnet-trace-select.png)
+
+   - Now select the **profile** from drop down list.
+
+     ![Select profile dotnet-trace](media/dotnet-trace-profile.png)
+
+   - Now select the **format** from drop down list.
+
+     ![Select format dotnet-trace](media/dotnet-trace-format.png)
+
+   - If everything is ok then the application starts and it starts collecting the trace file.
+
+     ![Tizen application running](media/dotnet-trace-running.png)
+
+   - Press **Cancel** button above to stop and generate the trace file.
+
+   - Once the trace file is generated, a message popup is shown to inform the user, and the file is added to the **trace** folder inside the **TizenDiagnostics** folder of the project.
+
+     ![Completed dotnet-trace](media/dotnet-trace-completed.png)
+
+
+
+### Step 2. Analyze the trace file
+   - There are different tools for different **Format** to view the trace diagnostics data.
+   - **nettrace**
+       - Once the trace file is collected, a message popup is shown with the option to open the generated trace file. Once we click the **YES** option. It will open the file in **PerfView** tool.
+       ![trace PerfView analysis view](media/dotnet-trace-perfview.png)
+       - Right click the trace (.nettrace) file in **File Explorer Panel** of VS Code and select **Tizen: Open in Diagnostics File Viewer**.. It will open the file in **PerfView** tool.
+       ![trace PerfView analysis view](media/dotnet-trace-open.png)
+       - **NOTE: Above two options to open/view nettrace file is supported only in Windows OS.**
+   - **speedscope**
+       - Right click the trace (.nettrace) file in **File Explorer Panel** of VS Code and select **Tizen: Open in Diagnostics File Viewer**.. It will open the file in **SpeedScope** web tool.
+       ![trace SpeedScope analysis view](media/dotnet-trace-speedscope.png)  
+   - **chromium**  
+   Open Google Chrome and type **chrome://tracing** or Microsoft Edge browser and type **edge://tracing**.  
+   Now click on **Load** button which fill open file explorer and select the **.chromium** file and click **Open**.
+       ![trace VS analysis view](media/dotnet-trace-chromium.png)
+
+
+## dotnet-dump
+
+### Step 1. Run dotnet-dump tool
+   - If no Tizen device is connected and no Tizen emulators are running then launch the type of emulator you want to use for diagnosing your application.
+
+     ![Launch Emulator](media/start_emulator.png)
+
+   - Open the **Command Palette** and select **Tizen.NET: Run dotnet diagnostics tools**.
+
+     ![Run dotnet-dump](media/dotnet-diagnostics.png)
+
+   - Now select the **dump** from drop down list.
+
+     ![Select dotnet-dump](media/dotnet-dump-select.png)
+
+   - Now select the **dump type** from drop down list.
+
+     ![Select type dotnet-dump](media/dotnet-dump-option.png)
+
+   - If everything is ok then the application starts and it starts collecting the dump file.
+
+     ![Tizen application running](media/dotnet-dump-running.png)
+
+   - Once the dump file is generated, a message popup is shown to inform the user, and the file is added to the **dump** folder inside the **TizenDiagnostics** folder of the project.
+   - Dump file analysis is also printed in output panel of VSCode.
+
+     ![Completed dotnet-dump](media/dotnet-dump-completed.png)
+
+
+### Step 2. Analyze the dump file
+   - Open the **sdb shell**
+   - Go to the folder (**/home/owner/share/tmp/sdk_tools**) containing the dump file
+   - Run the command **dotnet dump analyze {file_name}**
+
+**Note:** Please delete the dump file after analyze as it takes lot of memory space.
+

docs/application/vscode-ext/tools/leak-sanitizer-user-manual.md

@@ -0,0 +1,25 @@
+# Detecting Runtime Memory Errors with Leak Sanitizer
+- The Leak Sanitizer is a profiling tool designed to identify runtime memory leaks in Tizen native applications. It helps developers pinpoint sections of code that may lead to memory leaks during execution. By instrumenting the code during application compilation, the tool can detect memory leaks at runtime. If the program runs without crashing under Leak Sanitizer, it indicates that the code is free from potential memory leaks. This ensures safer and more efficient memory management in Tizen applications.
+
+## Using Leak Sanitizer
+- In the **File Explorer view**, click on view and select **Command Palette > Tizen: Profile with Leak Sanitizer**.
+
+  The profiling instruments the code and compiles the project for the Leak Sanitizer. Finally, it launches the application on the connected target or emulator, as illustrated in the following figure.
+
+  ![Launch Command](media/launch_lsan.png)
+  <br>
+
+- After the application is launched, run the application scenario you want to test
+- Visual studio code shows the profiling result after clicking on **Stop Profiling Button**.
+
+  ![Stop Profile Button](media/stop_profiling_button.png)
+   <br>
+
+- Once clicked on the **Stop Profiling Button**, application will crash if there are any errors hence the report will be generated and if there are no memory errors it will give the message no error found, as illustrated in the following figure.
+
+  ![Lsan UI Report](media/lsan_failure_report.png)
+
+## Source File Navigation on Failure
+  - When a failure occurs, you can click on the **line number associated with the failure which is generated in UI Report**. This action will open the corresponding source file in your editor and **navigate to the exact location where the failure has occurred**, as illustrated in the following figure.
+
+ ![Failure occured](media/failure_line_lsan.png)

docs/application/vscode-ext/tools/unit-test-code-coverage-user-manual.md

@@ -0,0 +1,35 @@
+# Get Unit Test information with Code Coverage
+Unit Test and Code coverage is a tool that helps you to understand the code quality of your application. It provides you with information about how much of your code is covered by unit tests by providing interface for viewing and analyzing native unit test results. It displays the test results in a tree view, showing the number of runs, defects, and failures you can see the details of each test suite and test case .
+<br>
+
+This helps with the testing experience by allowing you to conveniently review and understand the outcomes of your native unit tests within the VS Code extension.
+
+## Using the Unit Test and Code Coverage
+To use the Unit Test and Code Coverage tool:
+- Create a GTest application.
+- In the **File Explorer view**, click on **view** and select **Command Palette > Tizen: Create Tizen Project > Native > Tizen > Tizen-9.0 > GTest**, Then specify the desired project name for your GTest application. This will initiate the creation process and set up the necessary environment for running native unit tests within  VS Code extension
+
+    ![Create Gtest Application](media/gTest.png)
+<br>
+
+- In the **File Explorer view**, click on **view** and select **Command Palette > Tizen Native: Run Unit Test and Coverage**.
+
+    ![Launch Command](media/launch_utc.png)
+    <br>
+
+- All the **unit tests present in the Unit Test project** are executed and **coverage is determined based on the code covered by the unit tests**.
+- It also includes a **progress bar** that visually represents the **number of failures occurring** during the execution of native unit tests.
+
+    ![Native Unit Test Result](media/native_unit_test_result.png)
+    <br>
+
+- After the Unit Test project completes its execution, **VS code Extension displays the code coverage information in the browser in form of HTML**. The Unit Test Result and Code Coverage views provide a summary of the unit test results and code coverage percentage for each file.
+
+![Coverage Report](media/coverage_report.png)
+<br>
+
+## Source File Navigation on Failure
+- When a failure occurs, you can click on the **Failure Test Suite associated with the failure which is generated in Tree view**.
+- This action will open the corresponding source file in your editor and **navigate to the exact location where the failure has occurred**, as illustrated in the following figure.
+
+![Test Suite Failure Ocuured](media/test_suite_failure_line.png)