/// <summary>
/// Occurs whenever the installed application is enabled.
/// </summary>
+ /// <remarks>
+ /// This event is raised whenever the installed application is enabled. It provides information about the application that was enabled through the arguments passed in the event handler.
+ /// </remarks>
/// <since_tizen> 3 </since_tizen>
public static event EventHandler<ApplicationEnabledEventArgs> ApplicationEnabled
{
/// <summary>
/// Occurs whenever the installed application is disabled.
/// </summary>
+ /// <remarks>
+ /// This event is raised whenever the user disables an installed application through the Settings menu.
+ /// The event handler receives an argument of type ApplicationDisabledEventArgs which contains information about the disabled application.
+ /// </remarks>
/// <since_tizen> 3 </since_tizen>
public static event EventHandler<ApplicationDisabledEventArgs> ApplicationDisabled
{
/// <summary>
/// Occurs whenever the installed applications get launched.
/// </summary>
+ /// <remarks>
+ /// This event provides information about the application that was just launched, including its package ID, version, and other details.
+ /// It is useful for tracking and monitoring application launches in order to gather statistics or perform certain actions based on specific conditions.
+ /// </remarks>
/// <since_tizen> 3 </since_tizen>
public static event EventHandler<ApplicationLaunchedEventArgs> ApplicationLaunched
{
}
}
+
/// <summary>
/// Occurs whenever the installed applications get terminated.
/// </summary>
+ /// <remarks>
+ /// This event is raised whenever any application gets terminated on the device. It provides information about the terminated application through the arguments passed in the event handler.
+ /// </remarks>
/// <since_tizen> 3 </since_tizen>
public static event EventHandler<ApplicationTerminatedEventArgs> ApplicationTerminated
{
}
/// <summary>
- /// Gets the information of the installed applications asynchronously.
+ /// Asynchronously retrieves information about the installed applications.
/// </summary>
- /// <returns>The installed application info list.</returns>
+ /// <returns>An asynchronous task that returns a list containing information about the installed applications.</returns>
+ /// <remarks>
+ /// By calling this method, you can retrieve details about all the applications currently installed on the device. The returned list contains ApplicationInfo objects, which provide various properties such as package ID, version, and icon.
+ /// </remarks>
+ /// <example>
+ /// To get the information of the installed applications, you can call the following code snippet:
+ ///
+ /// <code>
+ /// var listApp = await ApplicationManager.GetInstalledApplicationsAsync();
+ /// Assert.IsNotEmpty(_listApp, "The list of installed app should not be empty.");
+ /// foreach (ApplicationInfo instapp in _listApp)
+ /// {
+ /// Console.WriteLine(instapp.ApplicationId);
+ /// }
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static async Task<IEnumerable<ApplicationInfo>> GetInstalledApplicationsAsync()
{
}
/// <summary>
- /// Gets the information of the installed applications with the ApplicationInfoFilter asynchronously.
+ /// Retrieves the information about installed applications that match the specified filter criteria in an asynchronous manner.
/// </summary>
- /// <param name="filter">Key-value pairs for filtering.</param>
- /// <returns>The installed application info list.</returns>
+ /// <remarks>
+ /// By specifying the desired filter criteria through the <paramref name="filter"/> argument, you can retrieve only those applications that meet these conditions. The returned result will contain a list of ApplicationInfo objects representing the matched applications.
+ /// </remarks>
+ /// <param name="filter">An ApplicationInfoFilter containing the desired filter criteria.</param>
+ /// <returns>An IEnumerable<ApplicationInfo> containing the information of the installed applications that match the specified filter.</returns>
+ /// <example>
+ /// The following code snippet demonstrates how to obtain the information of all installed applications:
+ /// <code>
+ /// var filter = new ApplicationInfoFilter();
+ /// filter.Filter.Add(ApplicationInfoFilter.Keys.Id, "org.exmaple.hello");
+ /// var apps = await GetInstalledApplicationsAsync(filter);
+ /// foreach (var app in apps)
+ /// {
+ /// Console.WriteLine(app.ApplicationId);
+ /// }
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static async Task<IEnumerable<ApplicationInfo>> GetInstalledApplicationsAsync(ApplicationInfoFilter filter)
{
}
/// <summary>
- /// Gets the information of the installed applications with the ApplicationInfoMetadataFilter asynchronously.
+ /// Asynchronously retrieves the information about installed applications filtered by the specified criteria in the form of ApplicationInfoMetadataFilter.
/// </summary>
- /// <param name="filter">Key-value pairs for filtering.</param>
- /// <returns>The installed application info list.</returns>
+ /// <remarks>
+ /// By providing the filter argument, you can specify various conditions such as package names, types, visibility status, etc., which will help narrow down the search results to only those that match the desired criteria.
+ /// The returned result is a list of ApplicationInfo objects containing detailed information about each matched application.
+ /// </remarks>
+ /// <param name="filter">A dictionary of key-value pairs used to define the specific filtering criteria.</param>
+ /// <returns>An enumerable collection of ApplicationInfo objects representing the installed applications that meet the specified filtering criteria.</returns>
+ /// <example>
+ /// To retrieve all visible applications:
+ ///
+ /// <code>
+ /// var filter = new ApplicationInfoMetadataFilter();
+ /// filter.Filter.Add("http://tizen.org/metadata/test-id", "org.exmaple.hello");
+ /// var apps = await GetInstalledApplicationsAsync(filter);
+ /// foreach (var app in apps)
+ /// {
+ /// Console.WriteLine(app.ApplicationId);
+ /// }
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static async Task<IEnumerable<ApplicationInfo>> GetInstalledApplicationsAsync(ApplicationInfoMetadataFilter filter)
{
}
/// <summary>
- /// Gets the information of the running applications asynchronously.
+ /// Asynchronously retrieves the information about currently running applications.
/// </summary>
- /// <returns>The application running context list.</returns>
+ /// <returns>An enumerable list containing details about the running applications.</returns>
+ /// <remarks>
+ /// This method provides an efficient way to gather information about all the active apps on the device without blocking the current thread. It returns a task which can be awaited in order to obtain the desired result.
+ /// </remarks>
+ /// <example>
+ /// Here's an example demonstrating how to retrieve the running applications and display their IDs:
+ /// <code>
+ /// await ApplicationManager.GetRunningApplicationsAsync().ContinueWith((task) => {
+ /// foreach (var app in task.Result) {
+ /// Console.WriteLine(app.ApplicationId);
+ /// }
+ /// });
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static async Task<IEnumerable<ApplicationRunningContext>> GetRunningApplicationsAsync()
{
}
/// <summary>
- /// Gets the information of the running applications including subapp asynchronously.
+ /// Asynchronously retrieves the information about all currently running applications, including subapps.
/// </summary>
- /// <returns>The application running context list.</returns>
+ /// <returns>An enumerable list containing details about the running applications.</returns>
+ /// <remarks>
+ /// This method provides access to the current state of all active applications on the device, allowing you to gather information such as their IDs, types, and states.
+ /// By utilizing this functionality, developers can gain insights into the overall system activity and make informed decisions based on the available data.
+ /// </remarks>
+ /// <example>
+ /// Here is an example that demonstrates how to utilize the GetAllRunningApplicationsAsync method in order to obtain information about the currently running applications:
+ /// <code>
+ /// // Initiate the call to get all running applications
+ /// IEnumerable<ApplicationRunningContext> runningApps = await GetAllRunningApplicationsAsync();
+ ///
+ /// // Iterate through the obtained list of running apps
+ /// foreach (var app in runningApps)
+ /// {
+ /// Console.WriteLine($"Id: {app.ApplicationId}");
+ /// }
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static async Task<IEnumerable<ApplicationRunningContext>> GetAllRunningApplicationsAsync()
{
}
/// <summary>
- /// Gets the information of the specified application with the application ID.
+ /// Retrieves the information of the specified application by its application ID.
/// </summary>
- /// <param name="applicationId">Application ID.</param>
- /// <returns>The application info.</returns>
+ /// <param name="applicationId">The ID of the target application.</param>
+ /// <returns>An object containing detailed information about the requested application.</returns>
+ /// <remarks>
+ /// This function enables you to obtain specific information about an application based on its application ID.
+ /// It returns an object that contains various attributes such as the package name, version, icon URL, etc., which are associated with the identified application.
+ /// If the specified application does not exist in the system, an error message will be thrown indicating that the requested application could not be found.
+ /// </remarks>
+ /// <example>
+ /// The following code snippet demonstrates how to retrieve the details of an application with the ID "org.example.app":
+ /// <code>
+ /// // Retrieve the application details
+ /// ApplicationInfo appInfo = ApplicationManager.GetInstalledApplication("org.example.app");
+ ///
+ /// // Print the package ID of the retrieved application
+ /// Console.WriteLine($"Package ID: {appInfo.PackageId}");
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static ApplicationInfo GetInstalledApplication(string applicationId)
{
}
/// <summary>
- /// Returns if the specified application is running or not.
+ /// Determines whether the specified application is currently running.
/// </summary>
- /// <param name="applicationId">The application ID.</param>
- /// <returns>Returns true if the given application is running, otherwise false.</returns>
- /// <exception cref="ArgumentException">Thrown when the given parameter is invalid.</exception>
+ /// <param name="applicationId">The unique identifier of the application to check.</param>
+ /// <returns>True if the application identified by the given ID is currently running, otherwise False.</returns>
+ /// <exception cref="ArgumentException">Thrown when the provided argument is invalid or missing.</exception>
+ /// <example>
+ /// The following code snippet demonstrates how to determine if a specific application is currently running:
+ ///
+ /// <code>
+ /// string applicationId = "org.example.app";
+ /// if (ApplicationManager.IsRunning(applicationId))
+ /// {
+ /// Console.WriteLine("The application with ID '{0}' is currently running.", applicationId);
+ /// }
+ /// else
+ /// {
+ /// Console.WriteLine("The application with ID '{0}' is not currently running.", applicationId);
+ /// }
+ /// </code>
+ /// </example>
/// <since_tizen> 3 </since_tizen>
public static bool IsRunning(string applicationId)
{
}
/// <summary>
- /// Returns the application id.
+ /// Retrieves the application ID based on the specified process ID.
/// </summary>
- /// <param name="processId">The application pid.</param>
- /// <returns>Returns the application id.</returns>
- /// <exception cref="ArgumentException">Thrown when the given parameter is invalid.</exception>
+ /// <remarks>
+ /// By providing the process ID as input, this function enables you to obtain the corresponding application ID.
+ /// It ensures that the correct application is identified even if multiple applications are running simultaneously.
+ /// </remarks>
+ /// <param name="processId">The process ID of the target application.</param>
+ /// <returns>The application ID associated with the given process ID.</returns>
+ /// <exception cref="ArgumentException">If the argument passed in is not valid.</exception>
+ /// <example>
+ /// The following code snippet demonstrates how to retrieve the application ID by calling the GetAppId() function:
+ ///
+ /// <code>
+ /// int processId = 12345; // Replace with actual process ID
+ /// string appId = GetAppId(processId);
+ /// Console.WriteLine($"Application ID: {appId}");
+ /// </code>
+ /// </example>
/// <since_tizen> 6 </since_tizen>
public static string GetAppId(int processId)
{
namespace Tizen.Applications
{
/// <summary>
- /// This class represents an application controlled lifecycles by the backend system.
+ /// The CoreApplication class provides functionality to manage application lifecycle events that are controlled by the backend system.
/// </summary>
+ /// <remarks>
+ /// By inheriting from the Application class, CoreApplication enables developers to handle various application states such as creating and terminating. It also allows them to define their own event handlers for these states.
+ /// </remarks>
/// <since_tizen> 3 </since_tizen>
public class CoreApplication : Application
{
private bool _disposedValue = false;
/// <summary>
- /// Initializes the CoreApplication class.
+ /// Initializes the CoreApplication class by providing a specific implementation of the ICoreBackend interface.
/// </summary>
- /// <param name="backend">The backend instance implementing ICoreBacked interface.</param>
+ /// <param name="backend">An instance of the desired implementation of the ICoreBackend interface.</param>
+ /// <remarks>
+ /// The CoreApplication class provides access to various features and functionalities related to application management.
+ /// By initializing the CoreApplication class with a specific implementation of the ICoreBackend interface, developers can customize the behavior and functionality of their applications based on their requirements.
+ /// It enables them to extend the capabilities of the default CoreApplication class and tailor it according to their needs.
+ /// </remarks>
/// <since_tizen> 3 </since_tizen>
public CoreApplication(ICoreBackend backend)
{
}
/// <summary>
- /// Overrides this method if want to handle behavior when the application is launched.
- /// If base.OnCreated() is not called, the event 'Created' will not be emitted.
+ /// Overrides this method if you want to handle specific behavior when the application is created.
+ /// Calling base.OnCreate() ensures that the default implementation is executed before any custom code in this method.
+ /// If base.OnCreate() is not called, the event 'Created' will not be emitted.
/// </summary>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnCreate()
}
/// <summary>
- /// Overrides this method if want to handle behavior when the application is terminated.
- /// If base.OnTerminate() is not called, the event 'Terminated' will not be emitted.
+ /// Override this method to define specific actions that occur when the application terminates.
+ /// Calling base.OnTerminate() ensures that the default termination process takes place and the 'Terminated' event is emitted.
/// </summary>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnTerminate()
}
/// <summary>
- /// Overrides this method if want to handle behavior when the application receives the appcontrol message.
- /// If base.OnAppControlReceived() is not called, the event 'AppControlReceived' will not be emitted.
+ /// Override this method to customize the behavior when the application receives the appcontrol message.
+ /// If base.OnAppControlReceived() is not called, the event 'AppControlReceived' will not be triggered.
/// </summary>
- /// <param name="e"></param>
+ /// <param name="e">The arguments passed in the appcontrol message</param>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnAppControlReceived(AppControlReceivedEventArgs e)
{
}
/// <summary>
- /// Overrides this method if want to handle behavior when the system memory is low.
- /// If base.OnLowMemory() is not called, the event 'LowMemory' will not be emitted.
+ /// Override this method to handle behavior when the system memory is low.
+ /// Calling base.OnLowMemory() ensures that the 'LowMemory' event is emitted.
/// </summary>
/// <param name="e">The low memory event argument</param>
/// <since_tizen> 3 </since_tizen>
}
/// <summary>
- /// Overrides this method if want to handle behavior when the system battery is low.
- /// If base.OnLowBattery() is not called, the event 'LowBattery' will not be emitted.
+ /// Override this method to handle the behavior when the system battery level drops.
+ /// If base.OnLowBattery() is not called, the LowBattery event will not be raised.
/// </summary>
- /// <param name="e">The low battery event argument</param>
+ /// <param name="e">The arguments for the low battery event</param>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnLowBattery(LowBatteryEventArgs e)
{
}
/// <summary>
- /// Overrides this method if want to handle behavior when the system language is changed.
- /// If base.OnLocaleChanged() is not called, the event 'LocaleChanged' will not be emitted.
+ /// Override this method to handle changes in the system language.
+ /// If base.OnLocaleChanged() is not called, the LocaleChanged event will not be triggered.
/// </summary>
- /// <param name="e">The locale changed event argument</param>
+ /// <param name="e">The arguments passed with the LocaleChanged event</param>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnLocaleChanged(LocaleChangedEventArgs e)
{
}
/// <summary>
- /// Overrides this method if want to handle behavior when the region format is changed.
- /// If base.OnRegionFormatChanged() is not called, the event 'RegionFormatChanged' will not be emitted.
+ /// Override this method to handle changes in the region format.
+ /// Make sure to call base.OnRegionFormatChanged() to ensure that the RegionFormatChanged event is raised.
/// </summary>
- /// <param name="e">The region format changed event argument</param>
+ /// <param name="e">The region format changed event arguments</param>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnRegionFormatChanged(RegionFormatChangedEventArgs e)
{
}
/// <summary>
- /// Overrides this method if want to handle behavior when the device orientation is changed.
- /// If base.OnRegionFormatChanged() is not called, the event 'RegionFormatChanged' will not be emitted.
+ /// Override this method to define specific behavior when the device orientation changes.
+ /// If base.OnDeviceOrientationChanged() is not called, the 'DeviceOrientationChanged' event will not be raised.
/// </summary>
- /// <param name="e">The device orientation changed event argument</param>
+ /// <param name="e">The arguments for the device orientation change event</param>
/// <since_tizen> 3 </since_tizen>
protected virtual void OnDeviceOrientationChanged(DeviceOrientationEventArgs e)
{
}
/// <summary>
- /// Override this method if you want to handle behavior when the time zone is changed.
- /// If base.OnTimeZoneChanged() is not called, the event "TimeZoneChanged" will not be emitted.
+ /// Override this method to handle changes in the current time zone.
+ /// Calling base.OnTimeZoneChanged() ensures that the TimeZoneChanged event is triggered.
/// </summary>
- /// <param name="e">The time zone changed event argument</param>
+ /// <param name="e">The arguments containing details about the time zone change</param>
/// <since_tizen> 11 </since_tizen>
protected virtual void OnTimeZoneChanged(TimeZoneChangedEventArgs e)
{
projects / platform / core / csapi / tizenfx.git / commitdiff