Tizen

Tizen.Applications namespace.<\/p>\nIt provides methods to manage the main event loop, the application state change events, and basic system events. Applications in the same package follow the same installation life cycle, which is handled by the application package manager.\nEach application in the package follows its own application life cycle. Each application in an application package can be identified by its ID.<\/p>\nA Tizen .NET application can be in one of several different states. Typically, the application is launched by the user from the launcher, or by another application. When the application is starting, the <code>OnCreate()<\/code> method is executed and the main event loop starts. The application is normally at the top of the window with a focus status.<\/p>\nWhen the application loses the focus status, the <code>OnPause()<\/code> method is invoked. The application can go into the pause state, which means that your application is not terminated, but continues to run in the background, when the following occurs:<\/p>\n<ul>\n<li>A new application is launched at the request of your application.<\/li>\n<li>The user requests to go to the home screen.<\/li>\n<li>A system event (such as an incoming phone call) occurs, and causes a resident application with a higher priority to become active and temporarily hide your application.<\/li>\n<li>An alarm is triggered for another application, which becomes the topmost window and hides your application.<\/li>\n<\/ul>\nThe application in the background goes into a suspended state. In the suspended state, the application process is executed with limited CPU resources. In other words, the platform does not allow the running of background applications, except for some exceptional applications (such as Media and Download) that necessarily work in the background. In this case, you can <a href=https://samsungtizenos.com/".//ui-app.md#allow_bg\">define a background category in the application manifest file<\/a>, to prevent the application from going into the suspended state.<\/p>\nWhen your application becomes visible again, the <code>OnResume()<\/code> method is invoked. The visibility returns, when the following occurs:<\/p>\n<ul>\n<li>Another application requests your application to run (for example, the Task Navigator, which shows all running applications and lets the user select any application to run).<\/li>\n<li>All applications on top of your application in the window stack finish.<\/li>\n<li>An alarm is triggered for your application, bringing it to the front and hiding other applications.<\/li>\n<\/ul>\nWhen your application starts exiting, the <code>OnTerminate()<\/code> method is invoked. Your application can start the termination process, when the following occurs:<\/p>\n<ul>\n<li>Your application itself requests to exit by calling the <code>Exit()<\/code> method to terminate the event loop.<\/li>\n<li>The low memory killer is killing your application in a low memory situation.<\/li>\n<\/ul>\nThe Tizen .NET application can be in one of several application states.<\/p>\nThe <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Applications.md/">Tizen.Applications namespace defines 5 states with corresponding state change methods. A state change method is triggered after each state change: whenever the application is created, starts running, or is paused, resumed, or terminated. The application must react to each state change appropriately.<\/p>\nTable: Application states<\/strong><\/p>\n<div class=\"overflow-auto grid table-fixed\" data-table-container=\"data-table-container\"><table>\n<thead>\n<tr>\n<th>State<\/th>\n<th>Description<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>READY<\/code><\/td>\n<td>Application is launched.<\/td>\n<\/tr>\n<tr>\n<td><code>CREATED<\/code><\/td>\n<td>Application starts the main loop.<\/td>\n<\/tr>\n<tr>\n<td><code>RUNNING<\/code><\/td>\n<td>Application is running and visible to the user.<\/td>\n<\/tr>\n<tr>\n<td><code>PAUSED<\/code><\/td>\n<td>Application is running but invisible to the user.<\/td>\n<\/tr>\n<tr>\n<td><code>TERMINATED<\/code><\/td>\n<td>Application is terminated.<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\nThe following figure illustrates the application state transitions.<\/p>\nFigure: Application state transitions<\/strong><\/p>\n<img src=https://samsungtizenos.com/"media//application_lifecycle_diagram.png/" alt=\"Application state transitions\" \/><\/p>\n<a name=\"state_change\"><\/a><\/p>\n<h2 id=\"content-tizen-net-application-state-change-methods\"><a href=https://samsungtizenos.com/"#content-tizen-net-application-state-change-methods\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Tizen .NET application state change methods<\/h2>\nThe following example shows the basic usage of the life cycle events provided by the <code>NUIApplication<\/code> class derived from the <code>CoreApplication<\/code> and <code>Application<\/code>. To use the <code>NUIApplication<\/code> class, <code>Tizen.NUI<\/code> namespace has to be included in the project. In the following example, two additional namespaces are used: <code>Tizen.NUI.BaseComponents<\/code> for the <code>TextLabel<\/code> component and <code>Tizen.Sensor<\/code> for the accelerometer access. The application overrides the <code>OnPause<\/code> and <code>OnResume<\/code> methods according to usage. The app suspends <code>Accelerometer<\/code> update callback to save power in the <code>Paused<\/code> state:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>using<\/span> <\/span>Tizen<\/span>.<\/span>NUI<\/span>;<\/span><\/span>\nusing<\/span> <\/span>Tizen<\/span>.<\/span>NUI<\/span>.<\/span>BaseComponents<\/span>;<\/span><\/span>\nusing<\/span> <\/span>Tizen<\/span>.<\/span>Sensor<\/span>;<\/span><\/span>\n<\/span><\/code><\/pre>\nThe main class of the application is defined as <code>Program<\/code>. In this case, the <code>Program<\/code> class derives from the <code>NUIApplication<\/code> object. The <code>Accelerometer<\/code> handle is declared in the main class to use it in all life cycle callbacks. The <code>OnCreate()<\/code> method uses <code>Tizen.Log.Info<\/code> to print information in <code>dlogutil<\/code> tool. For more information on logging into system in <code>Tizen<\/code>, see <a href=https://samsungtizenos.com/"..//native//guides//error//system-logs.md#dlogutil\">log viewer<\/a>. <code>OnCreate()<\/code> method initializes the UI and the <code>Accelerometer<\/code> component:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>class<\/span> <\/span>Program<\/span> : <\/span>NUIApplication<\/span><\/span>\n{<\/span><\/span>\n <\/span>private<\/span> <\/span>Accelerometer<\/span> <\/span>SensorAccelerometer<\/span> <\/span>=<\/span> <\/span>null<\/span>;<\/span><\/span>\n<\/span>\n <\/span>protected<\/span> <\/span>override<\/span> <\/span>void<\/span> <\/span>OnCreate<\/span>()<\/span><\/span>\n {<\/span><\/span>\n Tizen.Log.<\/span>Info<\/span>(<\/span>"LifecycleTest"<\/span>, <\/span>"OnCreate()"<\/span>);<\/span><\/span>\n <\/span>base<\/span>.<\/span>OnCreate<\/span>();<\/span><\/span>\n <\/span>InitSensors<\/span>();<\/span><\/span>\n <\/span>InitUI<\/span>();<\/span><\/span>\n }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe following code snippet is responsible for initializing <code>Accelerometer<\/code> sensor. The function setups the event handler for data update, and sets the update interval for one second. After setup, the <code>SensorAccelerometer.Start()<\/code> is called to start the measurements:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>void<\/span> <\/span>InitSensors<\/span>()<\/span><\/span>\n{<\/span><\/span>\n SensorAccelerometer <\/span>=<\/span> <\/span>new<\/span> <\/span>Accelerometer<\/span>();<\/span><\/span>\n SensorAccelerometer.Interval <\/span>=<\/span> <\/span>1000<\/span>;<\/span><\/span>\n SensorAccelerometer.DataUpdated <\/span>+=<\/span> OnAccelerometer;<\/span><\/span>\n SensorAccelerometer.<\/span>Start<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe UI setup is based on the basic template. A single <code>TextLabel<\/code> component is used to show the application UI and its running state:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>void<\/span> <\/span>InitUI<\/span>()<\/span><\/span>\n{<\/span><\/span>\n Window.Instance.KeyEvent <\/span>+=<\/span> OnKeyEvent;<\/span><\/span>\n<\/span>\n <\/span>TextLabel<\/span> <\/span>test<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>TextLabel<\/span>(<\/span>"Lifecycle test..."<\/span>)<\/span><\/span>\n {<\/span><\/span>\n HorizontalAlignment <\/span>=<\/span> HorizontalAlignment.Center,<\/span><\/span>\n VerticalAlignment <\/span>=<\/span> VerticalAlignment.Center,<\/span><\/span>\n TextColor <\/span>=<\/span> Color.Blue,<\/span><\/span>\n PointSize <\/span>=<\/span> <\/span>12.0f<\/span>,<\/span><\/span>\n HeightResizePolicy <\/span>=<\/span> ResizePolicyType.FillToParent,<\/span><\/span>\n WidthResizePolicy <\/span>=<\/span> ResizePolicyType.FillToParent<\/span><\/span>\n };<\/span><\/span>\n<\/span>\n Window.Instance.<\/span>GetDefaultLayer<\/span>().<\/span>Add<\/span>(test);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe <code>OnTerminate()<\/code> method logs information about the application termination:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>protected<\/span> <\/span>override<\/span> <\/span>void<\/span> <\/span>OnTerminate<\/span>()<\/span><\/span>\n{<\/span><\/span>\n Tizen.Log.<\/span>Info<\/span>(<\/span>"LifecycleTest"<\/span>, <\/span>"OnTerminate()"<\/span>);<\/span><\/span>\n <\/span>base<\/span>.<\/span>OnTerminate<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe <code>OnPause()<\/code> method is called when the application is suspended, but not killed. Then, it goes into the <code>Paused<\/code> state. To stop reading data from the <code>Accelerometer<\/code>, the <code>SensorAccelerometer.Stop()<\/code> method is used. Now, the application reduces resource usage. The main application window goes into the background now. The UI events are not received, but the data event handler has to be stopped manually:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>protected<\/span> <\/span>override<\/span> <\/span>void<\/span> <\/span>OnPause<\/span>()<\/span><\/span>\n{<\/span><\/span>\n Tizen.Log.<\/span>Info<\/span>(<\/span>"LifecycleTest"<\/span>, <\/span>"OnPause()"<\/span>);<\/span><\/span>\n <\/span>base<\/span>.<\/span>OnPause<\/span>();<\/span><\/span>\n<\/span>\n <\/span>if<\/span> (SensorAccelerometer <\/span>!=<\/span> <\/span>null<\/span>) SensorAccelerometer.<\/span>Stop<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe Tizen operating system may resume <code>Lifecycle<\/code> application, if it was not terminated. The data updating is restored using the <code>SensorAccelerometer.Start()<\/code> method. The application main window should be visible now:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>protected<\/span> <\/span>override<\/span> <\/span>void<\/span> <\/span>OnResume<\/span>()<\/span><\/span>\n{<\/span><\/span>\n Tizen.Log.<\/span>Info<\/span>(<\/span>"LifecycleTest"<\/span>, <\/span>"OnResume()"<\/span>);<\/span><\/span>\n <\/span>base<\/span>.<\/span>OnResume<\/span>();<\/span><\/span>\n<\/span>\n <\/span>if<\/span> (SensorAccelerometer <\/span>!=<\/span> <\/span>null<\/span>) SensorAccelerometer.<\/span>Start<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe callback setup in <code>InitSensors()<\/code> function is called every second. It prints debug information about a measured data from <code>Accelerometer<\/code> sensor. In the emulator case, this value can be changed using <code>Control Panel<\/code> tool. To observe changes you can use the <a href=https://samsungtizenos.com/"..//native//guides//error//system-logs.md#dlogutil\">log viewer<\/a>:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>void<\/span> <\/span>OnAccelerometer<\/span>(<\/span>object<\/span> <\/span>sender<\/span>, <\/span>AccelerometerDataUpdatedEventArgs<\/span> <\/span>args<\/span>)<\/span><\/span>\n{<\/span><\/span>\n Tizen.Log.<\/span>Info<\/span>(<\/span>"LifecycleTest"<\/span>, <\/span>string<\/span>.<\/span>Format<\/span>(<\/span>"X: {0}, Y: {1}, Z: {2}"<\/span>, args.X, args.Y, args.Z));<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nTo terminate the application, <code>OnKeyEvent()<\/code> handler is implemented. When the back key is pressed, the <code>Exit()<\/code> method is called to terminate the application. To minimize the application, the <code>Home<\/code> button should be pressed, which is handled by the Tizen operating system. Then, the <code>OnPause()<\/code> method is called:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>public<\/span> <\/span>void<\/span> <\/span>OnKeyEvent<\/span>(<\/span>object<\/span> <\/span>sender<\/span>, <\/span>Window<\/span>.<\/span>KeyEventArgs<\/span> <\/span>e<\/span>)<\/span><\/span>\n{<\/span><\/span>\n <\/span>if<\/span> (e.Key.State <\/span>==<\/span> Key.StateType.Down <\/span>&&<\/span> (e.Key.KeyPressedName <\/span>==<\/span> <\/span>"XF86Back"<\/span> <\/span>||<\/span> e.Key.KeyPressedName <\/span>==<\/span> <\/span>"Escape"<\/span>))<\/span><\/span>\n {<\/span><\/span>\n <\/span>Exit<\/span>();<\/span><\/span>\n }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe <code>Main<\/code> function code creates <code>Program<\/code> instance, calls <code>Run<\/code> method to change application state, and calls <code>OnCreate()<\/code> callback:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[] <\/span>args<\/span>)<\/span><\/span>\n{<\/span><\/span>\n <\/span>var<\/span> <\/span>app<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>Program<\/span>();<\/span><\/span>\n app.<\/span>Run<\/span>(args);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\nThe following screenshot presents dump from the <code>dlogutil<\/code> tool. The data reading is stopped when application changes state to <code>Paused<\/code>.<\/p>\nFigure: Application life cycle logs<\/strong><\/p>\n<img src=https://samsungtizenos.com/"media//application_lifecycle_logs.png/" alt=\"Life cycle logs\" \/><\/p>\nYou can check full source code here: <a href=https://samsungtizenos.com/"source-code//application_lifecycle.cs/">lifecycle sample<\/a>.<\/p>\n<h2 id=\"content-related-information\"><a href=https://samsungtizenos.com/"#content-related-information\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Related information<\/h2>\n<ul>\n<li>Dependencies\n<ul>\n<li>Tizen 4.0 and Higher<\/li>\n<\/ul>\n<\/li>\n<li>API References\n<ul>\n<li><a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Applications.Application.md/">Tizen.Applications.Application class<\/li>\n<li><a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Applications.CoreApplication.md/">Tizen.Applications.CoreApplication class<\/li>\n<li><a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Applications.CoreUIApplication.md/">Tizen.Applications.CoreUIApplication class<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n","table_of_content":"<ul class=\"table-of-contents\">\n<li><a href=https://samsungtizenos.com/"#content-tizen-net-application-state-change-methods\">Tizen .NET application state change methods<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-related-information\">Related information<\/a><\/li>\n<\/ul>\n","title":"Application Life Cycle","raw":null},{"class":"App\\Services\\Documentation\\Data\\RenderedMarkdown","s":"wrbl"}]},"memo":{"id":"QhbmmBx8vGnFIavcnoAk","name":"documentation::article","path":"docs\/application\/dotnet\/guides\/applications\/uiapplication\/application_lifecycle","method":"GET","release":"a-a-a","children":[],"scripts":[],"assets":[],"lazyLoaded":false,"lazyIsolated":true,"errors":[],"locale":"en","islands":[]},"checksum":"62cee96230899a984d7de1909a09abd7ea2f5fc9bf38caa7ccb9add225853b17"}" wire:effects="[]" wire:id="QhbmmBx8vGnFIavcnoAk" wire:name="documentation::article" x-init="$wire.__lazyLoad('{"data":{"forMount":[{"markdown":[{"body":"<h1 id=\"content-application-life-cycle\"><a href=\"#content-application-life-cycle\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Application Life Cycle<\/h1><div data-knowledge-base-metadata><\/div>\n<p>The Tizen .NET application model handles the application life cycle and system events. The Tizen .NET application life cycle is handled by the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Applications.md\">Tizen.Applications<\/a> namespace.<\/p>\n<p>It provides methods to manage the main event loop, the application state change events, and basic system events. Applications in the same package follow the same installation life cycle, which is handled by the application package manager.\nEach application in the package follows its own application life cycle. Each application in an application package can be identified by its ID.<\/p>\n<p>A Tizen .NET application can be in one of several different states.  Typically, the application is launched by the user from the launcher, or by another application. When the application is starting, the <code>OnCreate()<\/code> method is executed and the main event loop starts. The application is normally at the top of the window with a focus status.<\/p>\n<p>When the application loses the focus status, the <code>OnPause()<\/code> method is invoked. The application can go into the pause state, which means that your application is not terminated, but continues to run in the background, when the following occurs:<\/p>\n<ul>\n<li>A new application is launched at the request of your application.<\/li>\n<li>The user requests to go to the home screen.<\/li>\n<li>A system event (such as an incoming phone call) occurs, and causes a resident application with a higher priority to become active and temporarily hide your application.<\/li>\n<li>An alarm is triggered for another application, which becomes the topmost window and hides your application.<\/li>\n<\/ul>\n<p>The application in the background goes into a suspended state. In the suspended state, the application process is executed with limited CPU resources. In other words, the platform does not allow the running of background applications, except for some exceptional applications (such as Media and Download) that necessarily work in the background. In this case, you can <a href=\".\/ui-app.md#allow_bg\">define a background category in the application manifest file<\/a>, to prevent the application from going into the suspended state.<\/p>\n<p>When your application becomes visible again, the <code>OnResume()<\/code> method is invoked. The visibility returns, when the following occurs:<\/p>\n<ul>\n<li>Another application requests your application to run (for example, the Task Navigator, which shows all running applications and lets the user select any application to run).<\/li>\n<li>All applications on top of your application in the window stack finish.<\/li>\n<li>An alarm is triggered for your application, bringing it to the front and hiding other applications.<\/li>\n<\/ul>\n<p>When your application starts exiting, the <code>OnTerminate()<\/code> method is invoked. Your application can start the termination process, when the following occurs:<\/p>\n<ul>\n<li>Your application itself requests to exit by calling the <code>Exit()<\/code> method to terminate the event loop.<\/li>\n<li>The low memory killer is killing your application in a low memory situation.<\/li>\n<\/ul>\n<p>The Tizen .NET application can be in one of several application states.<\/p>\n<p>The <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Applications.md\">Tizen.Applications<\/a> namespace defines 5 states with corresponding state change methods. A state change method is triggered after each state change: whenever the application is created, starts running, or is paused, resumed, or terminated. The application must react to each state change appropriately.<\/p>\n<p><strong>Table: Application states<\/strong><\/p>\n<div class=\"overflow-auto grid table-fixed\" data-table-container=\"data-table-container\"><table>\n<thead>\n<tr>\n<th>State<\/th>\n<th>Description<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>READY<\/code><\/td>\n<td>Application is launched.<\/td>\n<\/tr>\n<tr>\n<td><code>CREATED<\/code><\/td>\n<td>Application starts the main loop.<\/td>\n<\/tr>\n<tr>\n<td><code>RUNNING<\/code><\/td>\n<td>Application is running and visible to the user.<\/td>\n<\/tr>\n<tr>\n<td><code>PAUSED<\/code><\/td>\n<td>Application is running but invisible to the user.<\/td>\n<\/tr>\n<tr>\n<td><code>TERMINATED<\/code><\/td>\n<td>Application is terminated.<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p>The following figure illustrates the application state transitions.<\/p>\n<p><strong>Figure: Application state transitions<\/strong><\/p>\n<p><img src=\"media\/application_lifecycle_diagram.png\" alt=\"Application state transitions\" \/><\/p>\n<p><a name=\"state_change\"><\/a><\/p>\n<h2 id=\"content-tizen-net-application-state-change-methods\"><a href=\"#content-tizen-net-application-state-change-methods\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Tizen .NET application state change methods<\/h2>\n<p>The following example shows the basic usage of the life cycle events provided by the <code>NUIApplication<\/code> class derived from the <code>CoreApplication<\/code> and <code>Application<\/code>. To use the <code>NUIApplication<\/code> class, <code>Tizen.NUI<\/code> namespace has to be included in the project. In the following example, two additional namespaces are used: <code>Tizen.NUI.BaseComponents<\/code> for the <code>TextLabel<\/code> component and <code>Tizen.Sensor<\/code> for the accelerometer access. The application overrides the <code>OnPause<\/code> and <code>OnResume<\/code> methods according to usage. The app suspends <code>Accelerometer<\/code> update callback to save power in the <code>Paused<\/code> state:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">using<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Tizen<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">NUI<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6F42C1;--shiki-dark:#F97583\">using<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Tizen<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">NUI<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">BaseComponents<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">using<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Tizen<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Sensor<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The main class of the application is defined as <code>Program<\/code>. In this case, the <code>Program<\/code> class derives from the <code>NUIApplication<\/code> object. The <code>Accelerometer<\/code> handle is declared in the main class to use it in all life cycle callbacks. The <code>OnCreate()<\/code> method uses <code>Tizen.Log.Info<\/code> to print information in <code>dlogutil<\/code> tool. For more information on logging into system in <code>Tizen<\/code>, see <a href=\"..\/..\/..\/..\/native\/guides\/error\/system-logs.md#dlogutil\">log viewer<\/a>. <code>OnCreate()<\/code> method initializes the UI and the <code>Accelerometer<\/code> component:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">class<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Program<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> : <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">NUIApplication<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">private<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Accelerometer<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">SensorAccelerometer<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">null<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">protected<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">override<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnCreate<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">()<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    {<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        Tizen.Log.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Info<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;LifecycleTest&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;OnCreate()&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">base<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnCreate<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">InitSensors<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">InitUI<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    }<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The following code snippet is responsible for initializing <code>Accelerometer<\/code> sensor. The function setups the event handler for data update, and sets the update interval for one second. After setup, the <code>SensorAccelerometer.Start()<\/code> is called to start the measurements:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">InitSensors<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">()<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    SensorAccelerometer <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">new<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Accelerometer<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    SensorAccelerometer.Interval <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">1000<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    SensorAccelerometer.DataUpdated <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">+=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> OnAccelerometer;<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    SensorAccelerometer.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Start<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The UI setup is based on the basic template. A single <code>TextLabel<\/code> component is used to show the application UI and its running state:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">InitUI<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">()<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    Window.Instance.KeyEvent <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">+=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> OnKeyEvent;<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">TextLabel<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">test<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">new<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#B392F0\">TextLabel<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#D73A49;--shiki-dark:#9ECBFF\">&quot;Lifecycle test...&quot;<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    {<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        HorizontalAlignment <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> HorizontalAlignment.Center,<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        VerticalAlignment <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> VerticalAlignment.Center,<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        TextColor <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> Color.Blue,<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        PointSize <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">12.0f<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">,<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        HeightResizePolicy <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> ResizePolicyType.FillToParent,<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        WidthResizePolicy <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> ResizePolicyType.FillToParent<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    };<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    Window.Instance.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">GetDefaultLayer<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">().<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Add<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(test);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The <code>OnTerminate()<\/code> method logs information about the application termination:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">protected<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">override<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#B392F0\">OnTerminate<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\">()<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    Tizen.Log.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Info<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;LifecycleTest&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;OnTerminate()&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">base<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnTerminate<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The <code>OnPause()<\/code> method is called when the application is suspended, but not killed. Then, it goes into the <code>Paused<\/code> state. To stop reading data from the <code>Accelerometer<\/code>, the <code>SensorAccelerometer.Stop()<\/code> method is used. Now, the application reduces resource usage. The main application window goes into the background now. The UI events are not received, but the data event handler has to be stopped manually:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">protected<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">override<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#B392F0\">OnPause<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\">()<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    Tizen.Log.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Info<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;LifecycleTest&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;OnPause()&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">base<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnPause<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">if<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> (SensorAccelerometer <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">!=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">null<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">) SensorAccelerometer.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Stop<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The Tizen operating system may resume <code>Lifecycle<\/code> application, if it was not terminated. The data updating is restored using the <code>SensorAccelerometer.Start()<\/code> method. The application main window should be visible now:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">protected<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">override<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#B392F0\">OnResume<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\">()<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    Tizen.Log.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Info<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;LifecycleTest&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;OnResume()&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">base<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnResume<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">if<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> (SensorAccelerometer <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">!=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">null<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">) SensorAccelerometer.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Start<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The callback setup in <code>InitSensors()<\/code> function is called every second. It prints debug information about a measured data from <code>Accelerometer<\/code> sensor. In the emulator case, this value can be changed using <code>Control Panel<\/code> tool. To observe changes you can use the <a href=\"..\/..\/..\/..\/native\/guides\/error\/system-logs.md#dlogutil\">log viewer<\/a>:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnAccelerometer<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#6F42C1;--shiki-dark:#F97583\">object<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">sender<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">AccelerometerDataUpdatedEventArgs<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">args<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    Tizen.Log.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Info<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;LifecycleTest&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">string<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Format<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;X: {0}, Y: {1}, Z: {2}&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, args.X, args.Y, args.Z));<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>To terminate the application, <code>OnKeyEvent()<\/code> handler is implemented. When the back key is pressed, the <code>Exit()<\/code> method is called to terminate the application. To minimize the application, the <code>Home<\/code> button should be pressed, which is handled by the Tizen operating system. Then, the <code>OnPause()<\/code> method is called:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">public<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnKeyEvent<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">object<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">sender<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Window<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">KeyEventArgs<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">e<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">if<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> (e.Key.State <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">==<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> Key.StateType.Down <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">&amp;&amp;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> (e.Key.KeyPressedName <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">==<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#9ECBFF\">&quot;XF86Back&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">||<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> e.Key.KeyPressedName <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">==<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#9ECBFF\">&quot;Escape&quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">))<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    {<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Exit<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    }<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The <code>Main<\/code> function code creates <code>Program<\/code> instance, calls <code>Run<\/code> method to change application state, and calls <code>OnCreate()<\/code> callback:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">static<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Main<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">string<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">[] <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">args<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#6F42C1;--shiki-dark:#F97583\">var<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">app<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">new<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Program<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    app.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Run<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(args);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The following screenshot presents dump from the <code>dlogutil<\/code> tool. The data reading is stopped when application changes state to <code>Paused<\/code>.<\/p>\n<p><strong>Figure: Application life cycle logs<\/strong><\/p>\n<p><img src=\"media\/application_lifecycle_logs.png\" alt=\"Life cycle logs\" \/><\/p>\n<p>You can check full source code here: <a href=\"source-code\/application_lifecycle.cs\">lifecycle sample<\/a>.<\/p>\n<h2 id=\"content-related-information\"><a href=\"#content-related-information\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Related information<\/h2>\n<ul>\n<li>Dependencies\n<ul>\n<li>Tizen 4.0 and Higher<\/li>\n<\/ul>\n<\/li>\n<li>API References\n<ul>\n<li><a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Applications.Application.md\">Tizen.Applications.Application<\/a> class<\/li>\n<li><a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Applications.CoreApplication.md\">Tizen.Applications.CoreApplication<\/a> class<\/li>\n<li><a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Applications.CoreUIApplication.md\">Tizen.Applications.CoreUIApplication<\/a> class<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n","table_of_content":"<ul class=\"table-of-contents\">\n<li><a href=\"#content-tizen-net-application-state-change-methods\">Tizen .NET application state change methods<\/a><\/li>\n<li><a href=\"#content-related-information\">Related information<\/a><\/li>\n<\/ul>\n","title":"Application Life Cycle","raw":null},{"class":"App\\Services\\Documentation\\Data\\RenderedMarkdown","s":"wrbl"}]},{"s":"arr"}]},"memo":{"id":"TRVJrLmlq5dlvlsWn0qx","name":"__mountParamsContainer","path":"docs\/application\/dotnet\/guides\/applications\/uiapplication\/application_lifecycle","method":"GET","release":"a-a-a"},"checksum":"2b707a367082ab3703a15dff49c504edd4c7b2755ac9ba95f7067524d4e3ebb8"}')" >

Customize your cookie preferences

Necessary

Analytics