examples/logging/logging-example.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "shared/view.h"
  19 #include <dali/dali.h>
  20 #include <dali-toolkit/dali-toolkit.h>
  21 #include <dali/devel-api/adaptor-framework/performance-logger.h>
  22 #include <sstream>
  23
  24 using namespace Dali;
  25
  26 // Define this so that it is interchangeable
  27 // "DP" stands for Device independent Pixels
  28 #define DP(x) x
  29
  30 //enum ButtonType
  31 //{
  32 //  PUSH_BUTTON,
  33 //  TOGGLE_BUTTON
  34 //};
  35 //
  36 //struct ButtonItem
  37 //{
  38 //  ButtonType type;
  39 //  const char* name;
  40 //  const char* text;
  41 //  const char* altText;
  42 //};
  43
  44 namespace
  45 {
  46
  47 const char* const BACKGROUND_IMAGE = DEMO_IMAGE_DIR "background-gradient.jpg";
  48 const char* const TOOLBAR_IMAGE = DEMO_IMAGE_DIR "top-bar.png";
  49
  50 const char* const TOOLBAR_TITLE = "Logging";
  51 //const int TOOLBAR_HEIGHT = 62;
  52
  53 const int MARGIN_SIZE = 10;
  54 const int TOP_MARGIN = 85;
  55
  56 const int LOGGER_GROUP_HEIGHT = 84;
  57 const int LOGGER_RADIO_GROUP_HEIGHT = 200;
  58
  59 const int LOGGER_RADIO_SPACING = 48;
  60
  61 const int CONSOLE_HEIGHT = 84;
  62
  63 const int BUTTON_WIDTH = 200;
  64 const int BUTTON_HEIGHT = LOGGER_GROUP_HEIGHT - MARGIN_SIZE * 2;
  65
  66 const Vector4 BACKGROUND_COLOUR( 1.0f, 1.0f, 1.0f, 0.15f );
  67
  68 // Button IDs
  69 const char* const LOGGER_1_RADIO_ID = "LOGGER_1_RADIO";
  70 const char* const LOGGER_2_RADIO_ID = "LOGGER_2_RADIO";
  71 const char* const LOGGER_3_RADIO_ID = "LOGGER_3_RADIO";
  72
  73 const char* const FREQUENCY_1_RADIO_ID = "FREQUENCY_1_RADIO";
  74 const char* const FREQUENCY_2_RADIO_ID = "FREQUENCY_2_RADIO";
  75 const char* const FREQUENCY_3_RADIO_ID = "FREQUENCY_3_RADIO";
  76
  77 const char* const CREATE_BUTTON_ID = "CREATE_BUTTON";
  78 const char* const DELETE_BUTTON_ID = "DELETE_BUTTON";
  79 const char* const START_BUTTON_ID = "START_BUTTON";
  80 const char* const STOP_BUTTON_ID = "STOP_BUTTON";
  81 const char* const HIGH_FREQ_BUTTON_ID = "INC_FREQ_BUTTON";
  82 const char* const LOW_FREQ_BUTTON_ID = "DEC_FREQ_BUTTON";
  83 const char* const ENABLE_BUTTON_ID = "ENABLE_BUTTON";
  84 const char* const DISABLE_BUTTON_ID = "DISABLE_BUTTON";
  85 const char* const VSYNC_BUTTON_ID = "VSYNC_BUTTON";
  86
  87 const char* const CREATE_BUTTON_TEXT = "Create";
  88 const char* const DELETE_BUTTON_TEXT = "Delete";
  89 const char* const START_BUTTON_TEXT = "Start";
  90 const char* const STOP_BUTTON_TEXT = "Stop";
  91 const char* const ENABLE_BUTTON_TEXT = "Enable";
  92 const char* const DISABLE_BUTTON_TEXT = "Disable";
  93 const char* const VSYNC_BUTTON_TEXT = "Vsync";
  94
  95 const char* const FREQUENCY_1_RADIO_TEXT = "1";
  96 const char* const FREQUENCY_2_RADIO_TEXT = "2";
  97 const char* const FREQUENCY_3_RADIO_TEXT = "10";
  98
  99 const char* const LOGGER_TEXT = "Logger:";
 100 const char* const FREQUENCY_TEXT = "Frequency (sec):";
 101
 102 const unsigned int NUM_LOGGERS = 3;
 103
 104 const unsigned int HIGH_FREQUENCY = 1;   // Seconds
 105 const unsigned int MEDIUM_FREQUENCY = 2;   // Seconds
 106 const unsigned int LOW_FREQUENCY = 10;   // Seconds
 107 const unsigned int NUM_FREQUENCIES = 3;
 108
 109 }  // namespace
 110
 111 /**
 112  * This example is a test harness for performance loggers.
 113  *
 114  * Press one of the create buttons to create a logger. This will output on vsync at the default frequency (2 seconds).
 115  * In case nothing appears in the log, force a vsync by touching anywhere on the screen. Loggers can be deleted
 116  * with the delete buttons. They can be enabled or disabled in which case logging will appear or disappear in the console
 117  * respectively. To record information in a logger press the start and then stop button in succession quickly in between
 118  * the time period when it would print to the console. This is necessary as the logger is cleared of information when
 119  * it prints. The output will contain the smallest and largest times between start and stop recorded (minimum and maximum),
 120  * the total time recorded by the logger as well as the average and standard deviation of all the times recorded. The
 121  * frequency of log output can be set to high frequency (every 1 second) or low frequency (every 10 seconds).
 122  */
 123 class LoggingController: public ConnectionTracker
 124 {
 125  public:
 126
 127   LoggingController( Application& application )
 128   : mApplication( application ),
 129     mView(),
 130     mToolBar(),
 131     mContentLayer(),
 132     mAnimation(),
 133     mPerformanceLoggerNames(),
 134     mPerformanceLoggers(),
 135     mCurrentLogger( 0 ),
 136     mLoggerStates(),
 137     mLogRadioButtons(),
 138     mFrequencyRadioButtons()
 139   {
 140     // Connect to the Application's Init signal
 141     mApplication.InitSignal().Connect( this, &LoggingController::Create );
 142   }
 143
 144   ~LoggingController()
 145   {
 146     // Nothing to do here
 147   }
 148
 149   void Create( Application& application )
 150   {
 151     // The Init signal is received once (only) during the Application lifetime
 152
 153     mCurrentLogger = 0;
 154     mPerformanceLoggers.reserve( NUM_LOGGERS );
 155     mPerformanceLoggers.resize( NUM_LOGGERS );
 156
 157     mPerformanceLoggerNames.reserve( NUM_LOGGERS );
 158     mPerformanceLoggerNames.resize( NUM_LOGGERS );
 159
 160     mLoggerStates.reserve( NUM_LOGGERS );
 161     mLoggerStates.resize( NUM_LOGGERS );
 162
 163     mLogRadioButtons.reserve( NUM_LOGGERS );
 164     mLogRadioButtons.resize( NUM_LOGGERS );
 165
 166     mFrequencyRadioButtons.reserve( NUM_FREQUENCIES );
 167     mFrequencyRadioButtons.resize( NUM_FREQUENCIES );
 168
 169     // Respond to key events
 170     Stage::GetCurrent().KeyEventSignal().Connect(this, &LoggingController::OnKeyEvent);
 171
 172     // Creates a default view with a default tool bar.
 173     // The view is added to the stage.
 174     mContentLayer = DemoHelper::CreateView( application,
 175                                             mView,
 176                                             mToolBar,
 177                                             BACKGROUND_IMAGE,
 178                                             TOOLBAR_IMAGE,
 179                                             TOOLBAR_TITLE );
 180
 181     Toolkit::TableView contentTable = Toolkit::TableView::New( 6, 1 );
 182     contentTable.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 183     contentTable.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 184     contentTable.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 185     contentTable.SetParentOrigin( ParentOrigin::TOP_LEFT );
 186     contentTable.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE * 0.5f ) );
 187
 188     for( unsigned int i = 0; i < contentTable.GetRows(); ++i )
 189     {
 190       contentTable.SetFitHeight( i );
 191     }
 192
 193     contentTable.SetPosition( 0.0f, TOP_MARGIN );
 194
 195     mContentLayer.Add( contentTable );
 196
 197
 198     // Logger selector radio group
 199     Toolkit::TableView radioGroupBackground = Toolkit::TableView::New( 2, 1 );
 200     radioGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 201     radioGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 202     radioGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 203     radioGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 204     radioGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 205     radioGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE * 0.5f ) );
 206
 207     contentTable.Add( radioGroupBackground );
 208
 209     // Label
 210     {
 211       Toolkit::TextLabel label = Toolkit::TextLabel::New( LOGGER_TEXT );
 212       label.SetParentOrigin( ParentOrigin::TOP_LEFT );
 213       label.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 214       label.SetPosition( DP(MARGIN_SIZE), DP(MARGIN_SIZE) );
 215       label.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 216
 217       radioGroupBackground.Add( label );
 218       radioGroupBackground.SetFitHeight( 0 );
 219     }
 220
 221     // Radio group
 222     Toolkit::TableView radioButtonsGroup = Toolkit::TableView::New( 3, 1 );
 223     radioButtonsGroup.SetCellPadding( Size( 0.0f, MARGIN_SIZE * 0.5f ) );
 224     radioButtonsGroup.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 225     for( unsigned int i = 0; i < radioButtonsGroup.GetRows(); ++i )
 226     {
 227       radioButtonsGroup.SetFitHeight( i );
 228     }
 229     radioButtonsGroup.SetFitWidth( 0 );
 230
 231     radioGroupBackground.Add( radioButtonsGroup );
 232     radioGroupBackground.SetFitHeight( 1 );
 233
 234     int radioX = 0;
 235     int radioY = 0;
 236
 237     // Radio 1
 238     {
 239       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 240       radioButton.SetName( LOGGER_1_RADIO_ID );
 241       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 242       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 243       radioButton.SetPosition( DP(radioX), DP(radioY) );
 244       radioButton.SetProperty( Toolkit::Button::Property::SELECTED, true );
 245
 246       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 247
 248       radioButtonsGroup.Add( radioButton );
 249       mLogRadioButtons[0] = radioButton;
 250     }
 251
 252     // Radio 2
 253     {
 254       radioY += LOGGER_RADIO_SPACING;
 255
 256       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 257       radioButton.SetName( LOGGER_2_RADIO_ID );
 258       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 259       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 260       radioButton.SetPosition( DP(radioX), DP(radioY) );
 261
 262       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 263
 264       radioButtonsGroup.Add( radioButton );
 265       mLogRadioButtons[1] = radioButton;
 266     }
 267
 268     // Radio 3
 269     {
 270       radioY += LOGGER_RADIO_SPACING;
 271
 272       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 273       radioButton.SetName( LOGGER_3_RADIO_ID );
 274       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 275       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 276       radioButton.SetPosition( DP(radioX), DP(radioY) );
 277
 278       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 279
 280       radioButtonsGroup.Add( radioButton );
 281       mLogRadioButtons[2] = radioButton;
 282     }
 283
 284     // Create/delete/disable group
 285     Toolkit::TableView createGroupBackground = Toolkit::TableView::New( 1, 2 );
 286     createGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 287     createGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 288     createGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 289     createGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 290     createGroupBackground.SetFitHeight( 0 );
 291
 292     contentTable.Add( createGroupBackground );
 293
 294     {
 295       Toolkit::PushButton button = Toolkit::PushButton::New();
 296       button.SetName( CREATE_BUTTON_ID );
 297       button.SetProperty( Toolkit::Button::Property::LABEL, CREATE_BUTTON_TEXT);
 298       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 299       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 300       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 301
 302       createGroupBackground.Add( button );
 303     }
 304
 305     {
 306       Toolkit::PushButton button = Toolkit::PushButton::New();
 307       button.SetName( DELETE_BUTTON_ID );
 308       button.SetProperty( Toolkit::Button::Property::LABEL, DELETE_BUTTON_TEXT);
 309       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 310       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 311       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 312
 313       createGroupBackground.Add( button );
 314     }
 315
 316     // Start/stop group
 317
 318     Toolkit::TableView timingGroupBackground = Toolkit::TableView::New( 1, 2 );
 319     timingGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 320     timingGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 321     timingGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 322     timingGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 323     timingGroupBackground.SetFitHeight( 0 );
 324
 325     contentTable.Add( timingGroupBackground );
 326
 327     {
 328       Toolkit::PushButton button = Toolkit::PushButton::New();
 329       button.SetName( START_BUTTON_ID );
 330       button.SetProperty( Toolkit::Button::Property::LABEL, START_BUTTON_TEXT);
 331       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 332       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 333       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 334
 335       timingGroupBackground.Add( button );
 336     }
 337
 338     {
 339       Toolkit::PushButton button = Toolkit::PushButton::New();
 340       button.SetName( STOP_BUTTON_ID );
 341       button.SetProperty( Toolkit::Button::Property::LABEL, STOP_BUTTON_TEXT);
 342       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 343       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 344       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 345
 346       timingGroupBackground.Add( button );
 347     }
 348
 349     // Enable/disable group
 350     Toolkit::TableView enableGroupBackground = Toolkit::TableView::New( 1, 2 );
 351     enableGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 352     enableGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 353     enableGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 354     enableGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 355     enableGroupBackground.SetFitHeight( 0 );
 356
 357     contentTable.Add( enableGroupBackground );
 358
 359     {
 360       Toolkit::PushButton button = Toolkit::PushButton::New();
 361       button.SetName( ENABLE_BUTTON_ID );
 362       button.SetProperty( Toolkit::Button::Property::LABEL, ENABLE_BUTTON_TEXT);
 363       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 364       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 365       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 366
 367       enableGroupBackground.Add( button );
 368     }
 369
 370     {
 371       Toolkit::PushButton button = Toolkit::PushButton::New();
 372       button.SetName( DISABLE_BUTTON_ID );
 373       button.SetProperty( Toolkit::Button::Property::LABEL, DISABLE_BUTTON_TEXT);
 374       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 375       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 376       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 377
 378       enableGroupBackground.Add( button );
 379     }
 380
 381     // Logger selector radio group
 382     Toolkit::TableView frequencyRadioGroupBackground = Toolkit::TableView::New( 2, 1 );
 383     frequencyRadioGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 384     frequencyRadioGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 385     frequencyRadioGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 386     frequencyRadioGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE * 0.5f ) );
 387     frequencyRadioGroupBackground.SetFitHeight( 0 );
 388     frequencyRadioGroupBackground.SetFitHeight( 1 );
 389
 390     contentTable.Add( frequencyRadioGroupBackground );
 391
 392     // Label
 393     {
 394       Toolkit::TextLabel label = Toolkit::TextLabel::New( FREQUENCY_TEXT );
 395
 396       frequencyRadioGroupBackground.Add( label );
 397     }
 398
 399     // Radio group
 400     Toolkit::TableView frequencyRadioButtonsGroup = Toolkit::TableView::New( 1, 3 );
 401     frequencyRadioButtonsGroup.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 402     frequencyRadioButtonsGroup.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 403     frequencyRadioButtonsGroup.SetFitHeight( 0 );
 404     frequencyRadioButtonsGroup.SetPadding( Padding( 0.0f, 0.0f, MARGIN_SIZE, 0.0f ) );
 405
 406     frequencyRadioGroupBackground.Add( frequencyRadioButtonsGroup );
 407
 408     // Radio 1
 409     {
 410       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_1_RADIO_TEXT );
 411       radioButton.SetName( FREQUENCY_1_RADIO_ID );
 412
 413       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 414
 415       frequencyRadioButtonsGroup.Add( radioButton );
 416       mFrequencyRadioButtons[0] = radioButton;
 417     }
 418
 419     // Radio 2
 420     {
 421       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_2_RADIO_TEXT );
 422       radioButton.SetName( FREQUENCY_2_RADIO_ID );
 423
 424       radioButton.SetProperty( Toolkit::Button::Property::SELECTED, true );
 425
 426       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 427
 428       frequencyRadioButtonsGroup.Add( radioButton );
 429       mFrequencyRadioButtons[1] = radioButton;
 430     }
 431
 432     // Radio 3
 433     {
 434       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_3_RADIO_TEXT );
 435       radioButton.SetName( FREQUENCY_3_RADIO_ID );
 436
 437       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 438
 439       frequencyRadioButtonsGroup.Add( radioButton );
 440       mFrequencyRadioButtons[2] = radioButton;
 441     }
 442
 443     // Vsync group
 444     Toolkit::TableView vsyncGroupBackground = Toolkit::TableView::New( 1, 1 );
 445     vsyncGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 446     vsyncGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 447     vsyncGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 448     vsyncGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 449     vsyncGroupBackground.SetFitHeight( 0 );
 450
 451     contentTable.Add( vsyncGroupBackground );
 452
 453     {
 454       Toolkit::PushButton button = Toolkit::PushButton::New();
 455       button.SetName( VSYNC_BUTTON_ID );
 456       button.SetProperty( Toolkit::Button::Property::LABEL, VSYNC_BUTTON_TEXT);
 457       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 458       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 459       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 460
 461       vsyncGroupBackground.Add( button );
 462     }
 463
 464     WriteConsole();
 465   }
 466
 467   void WriteConsole()
 468   {
 469     for( unsigned int i = 0; i < NUM_LOGGERS; ++i)
 470     {
 471       std::stringstream ss;
 472       ss << (i + 1) << ") " << ((mPerformanceLoggers[i]) ? "Created" : "Deleted")
 473          << ", " << ((mLoggerStates[i].isTiming) ? "Started" : "Stopped")
 474          << ", " << ((mLoggerStates[i].isEnabled) ? "Enabled" : "Disabled");
 475
 476       mLogRadioButtons[i].SetProperty( Toolkit::Button::Property::LABEL, ss.str() );
 477     }
 478   }
 479
 480   bool LoggingRadioSelect( Toolkit::Button button )
 481   {
 482     bool isSelected = button.GetProperty( Toolkit::Button::Property::SELECTED ).Get<bool>();
 483     if( !isSelected )
 484     {
 485       return true;
 486     }
 487
 488     if( button.GetName() == LOGGER_1_RADIO_ID )
 489     {
 490       mCurrentLogger = 0;
 491     }
 492     else if( button.GetName() == LOGGER_2_RADIO_ID )
 493     {
 494       mCurrentLogger = 1;
 495     }
 496     else if( button.GetName() == LOGGER_3_RADIO_ID )
 497     {
 498       mCurrentLogger = 2;
 499     }
 500
 501     UpdateState();
 502
 503     return true;
 504   }
 505
 506   void UpdateState()
 507   {
 508     DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 509     const unsigned int frequency = mLoggerStates[mCurrentLogger].frequency;
 510     if( frequency == HIGH_FREQUENCY )
 511     {
 512       mFrequencyRadioButtons[0].SetProperty( Toolkit::Button::Property::SELECTED, true );
 513     }
 514     else if( frequency == MEDIUM_FREQUENCY )
 515     {
 516       mFrequencyRadioButtons[1].SetProperty( Toolkit::Button::Property::SELECTED, true );
 517     }
 518     else if( frequency == LOW_FREQUENCY )
 519     {
 520       mFrequencyRadioButtons[2].SetProperty( Toolkit::Button::Property::SELECTED, true );
 521     }
 522   }
 523
 524   bool FrequencyRadioSelect( Toolkit::Button button )
 525   {
 526     bool isSelected = button.GetProperty( Toolkit::Button::Property::SELECTED ).Get<bool>();
 527     if( !isSelected )
 528     {
 529       return true;
 530     }
 531
 532     if( button.GetName() == FREQUENCY_1_RADIO_ID )
 533     {
 534       if( mPerformanceLoggers[mCurrentLogger] )
 535       {
 536         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 537         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( HIGH_FREQUENCY );
 538
 539         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 540         mLoggerStates[mCurrentLogger].frequency = HIGH_FREQUENCY;
 541       }
 542     }
 543     else if( button.GetName() == FREQUENCY_2_RADIO_ID )
 544     {
 545       if( mPerformanceLoggers[mCurrentLogger] )
 546       {
 547         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 548         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( MEDIUM_FREQUENCY );
 549
 550         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 551         mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 552       }
 553     }
 554     else if( button.GetName() == FREQUENCY_3_RADIO_ID )
 555     {
 556       if( mPerformanceLoggers[mCurrentLogger] )
 557       {
 558         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 559         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( LOW_FREQUENCY );
 560
 561         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 562         mLoggerStates[mCurrentLogger].frequency = LOW_FREQUENCY;
 563       }
 564     }
 565
 566     return true;
 567   }
 568
 569   void OnKeyEvent( const KeyEvent& event )
 570   {
 571     if( event.state == KeyEvent::Down )
 572     {
 573       if( IsKey( event, Dali::DALI_KEY_ESCAPE ) || IsKey( event, Dali::DALI_KEY_BACK ) )
 574       {
 575         // Exit application when click back or escape.
 576         mApplication.Quit();
 577       }
 578     }
 579   }
 580
 581   bool OnButtonClicked(Toolkit::Button button)
 582   {
 583     if( button.GetName() == CREATE_BUTTON_ID )
 584     {
 585       std::stringstream ss;
 586       ss << "Test logger " << (mCurrentLogger + 1);
 587
 588       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggerNames.size() );
 589       mPerformanceLoggerNames[mCurrentLogger] = ss.str();
 590
 591       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 592       mPerformanceLoggers[mCurrentLogger] = Dali::PerformanceLogger::New( mPerformanceLoggerNames[mCurrentLogger].c_str() );
 593
 594       DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 595       mLoggerStates[mCurrentLogger].isTiming = false;
 596       mLoggerStates[mCurrentLogger].isEnabled = true;
 597       mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 598
 599       UpdateState();
 600     }
 601     else if ( button.GetName() == DELETE_BUTTON_ID )
 602     {
 603       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 604       mPerformanceLoggers[mCurrentLogger].Reset();
 605
 606       DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 607       mLoggerStates[mCurrentLogger].isTiming = false;
 608       mLoggerStates[mCurrentLogger].isEnabled = true;
 609       mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 610
 611       UpdateState();
 612     }
 613     else if ( button.GetName() == START_BUTTON_ID )
 614     {
 615       if( mPerformanceLoggers[mCurrentLogger] )
 616       {
 617         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 618         mPerformanceLoggers[mCurrentLogger].AddMarker( Dali::PerformanceLogger::START_EVENT );
 619
 620         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 621         mLoggerStates[mCurrentLogger].isTiming = true;
 622       }
 623     }
 624     else if ( button.GetName() == STOP_BUTTON_ID )
 625     {
 626       if( mPerformanceLoggers[mCurrentLogger] )
 627       {
 628         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 629         mPerformanceLoggers[mCurrentLogger].AddMarker( Dali::PerformanceLogger::END_EVENT );
 630
 631         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 632         mLoggerStates[mCurrentLogger].isTiming = false;
 633       }
 634     }
 635     else if ( button.GetName() == ENABLE_BUTTON_ID )
 636     {
 637       if( mPerformanceLoggers[mCurrentLogger] )
 638       {
 639         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 640         mPerformanceLoggers[mCurrentLogger].EnableLogging( true );
 641
 642         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 643         mLoggerStates[mCurrentLogger].isEnabled = true;
 644       }
 645     }
 646     else if ( button.GetName() == DISABLE_BUTTON_ID )
 647     {
 648       if( mPerformanceLoggers[mCurrentLogger] )
 649       {
 650         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 651         mPerformanceLoggers[mCurrentLogger].EnableLogging( false );
 652
 653         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 654         mLoggerStates[mCurrentLogger].isEnabled = false;
 655       }
 656     }
 657
 658     WriteConsole();
 659
 660     return true;
 661   }
 662
 663 private:
 664
 665   struct LoggerState
 666   {
 667     LoggerState() : frequency( 0 ), isTiming( false ), isEnabled( true ) {}
 668
 669     unsigned int frequency;
 670     bool isTiming;
 671     bool isEnabled;
 672   };
 673
 674   Application&      mApplication;
 675   Toolkit::Control  mView;                   ///< The View instance.
 676   Toolkit::ToolBar  mToolBar;                ///< The View's Toolbar.
 677   Layer             mContentLayer;           ///< Content layer
 678
 679   Animation      mAnimation;
 680
 681   typedef std::vector< std::string > Strings;
 682   Strings mPerformanceLoggerNames;
 683
 684   typedef std::vector< Dali::PerformanceLogger > PerformanceLoggers;
 685   PerformanceLoggers mPerformanceLoggers;
 686   unsigned int mCurrentLogger;
 687
 688   typedef std::vector< LoggerState > LoggerStates;
 689   LoggerStates mLoggerStates;
 690
 691   typedef std::vector< Toolkit::RadioButton > RadioButtons;
 692   RadioButtons mLogRadioButtons;
 693   RadioButtons mFrequencyRadioButtons;
 694 };
 695
 696 void RunTest( Application& application )
 697 {
 698   LoggingController test( application );
 699
 700   application.MainLoop();
 701 }
 702
 703 // Entry point for Linux & Tizen applications
 704 //
 705 int DALI_EXPORT_API main( int argc, char **argv )
 706 {
 707   Application application = Application::New( &argc, &argv, DEMO_THEME_PATH );
 708
 709   RunTest( application );
 710
 711   return 0;
 712 }