examples/logging/logging-example.cpp

   1 /*
   2  * Copyright (c) 2014 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   {
 130     // Connect to the Application's Init signal
 131     mApplication.InitSignal().Connect( this, &LoggingController::Create );
 132   }
 133
 134   ~LoggingController()
 135   {
 136     // Nothing to do here
 137   }
 138
 139   void Create( Application& application )
 140   {
 141     // The Init signal is received once (only) during the Application lifetime
 142
 143     mCurrentLogger = 0;
 144     mPerformanceLoggers.reserve( NUM_LOGGERS );
 145     mPerformanceLoggers.resize( NUM_LOGGERS );
 146
 147     mPerformanceLoggerNames.reserve( NUM_LOGGERS );
 148     mPerformanceLoggerNames.resize( NUM_LOGGERS );
 149
 150     mLoggerStates.reserve( NUM_LOGGERS );
 151     mLoggerStates.resize( NUM_LOGGERS );
 152
 153     mLogRadioButtons.reserve( NUM_LOGGERS );
 154     mLogRadioButtons.resize( NUM_LOGGERS );
 155
 156     mFrequencyRadioButtons.reserve( NUM_FREQUENCIES );
 157     mFrequencyRadioButtons.resize( NUM_FREQUENCIES );
 158
 159     // Respond to key events
 160     Stage::GetCurrent().KeyEventSignal().Connect(this, &LoggingController::OnKeyEvent);
 161
 162     // Creates a default view with a default tool bar.
 163     // The view is added to the stage.
 164     mContentLayer = DemoHelper::CreateView( application,
 165                                             mView,
 166                                             mToolBar,
 167                                             BACKGROUND_IMAGE,
 168                                             TOOLBAR_IMAGE,
 169                                             TOOLBAR_TITLE );
 170
 171     Toolkit::TableView contentTable = Toolkit::TableView::New( 6, 1 );
 172     contentTable.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 173     contentTable.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 174     contentTable.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 175     contentTable.SetParentOrigin( ParentOrigin::TOP_LEFT );
 176     contentTable.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE * 0.5f ) );
 177
 178     for( unsigned int i = 0; i < contentTable.GetRows(); ++i )
 179     {
 180       contentTable.SetFitHeight( i );
 181     }
 182
 183     contentTable.SetPosition( 0.0f, TOP_MARGIN );
 184
 185     mContentLayer.Add( contentTable );
 186
 187
 188     // Logger selector radio group
 189     Toolkit::TableView radioGroupBackground = Toolkit::TableView::New( 2, 1 );
 190     radioGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 191     radioGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 192     radioGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 193     radioGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 194     radioGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 195     radioGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE * 0.5f ) );
 196
 197     contentTable.Add( radioGroupBackground );
 198
 199     // Label
 200     {
 201       Toolkit::TextLabel label = Toolkit::TextLabel::New( LOGGER_TEXT );
 202       label.SetParentOrigin( ParentOrigin::TOP_LEFT );
 203       label.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 204       label.SetPosition( DP(MARGIN_SIZE), DP(MARGIN_SIZE) );
 205       label.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 206
 207       radioGroupBackground.Add( label );
 208       radioGroupBackground.SetFitHeight( 0 );
 209     }
 210
 211     // Radio group
 212     Toolkit::TableView radioButtonsGroup = Toolkit::TableView::New( 3, 1 );
 213     radioButtonsGroup.SetCellPadding( Size( 0.0f, MARGIN_SIZE * 0.5f ) );
 214     radioButtonsGroup.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 215     for( unsigned int i = 0; i < radioButtonsGroup.GetRows(); ++i )
 216     {
 217       radioButtonsGroup.SetFitHeight( i );
 218     }
 219     radioButtonsGroup.SetFitWidth( 0 );
 220
 221     radioGroupBackground.Add( radioButtonsGroup );
 222     radioGroupBackground.SetFitHeight( 1 );
 223
 224     int radioX = 0;
 225     int radioY = 0;
 226
 227     // Radio 1
 228     {
 229       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 230       radioButton.SetName( LOGGER_1_RADIO_ID );
 231       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 232       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 233       radioButton.SetPosition( DP(radioX), DP(radioY) );
 234       radioButton.SetSelected( true );
 235
 236       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 237
 238       radioButtonsGroup.Add( radioButton );
 239       mLogRadioButtons[0] = radioButton;
 240     }
 241
 242     // Radio 2
 243     {
 244       radioY += LOGGER_RADIO_SPACING;
 245
 246       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 247       radioButton.SetName( LOGGER_2_RADIO_ID );
 248       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 249       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 250       radioButton.SetPosition( DP(radioX), DP(radioY) );
 251
 252       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 253
 254       radioButtonsGroup.Add( radioButton );
 255       mLogRadioButtons[1] = radioButton;
 256     }
 257
 258     // Radio 3
 259     {
 260       radioY += LOGGER_RADIO_SPACING;
 261
 262       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 263       radioButton.SetName( LOGGER_3_RADIO_ID );
 264       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 265       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 266       radioButton.SetPosition( DP(radioX), DP(radioY) );
 267
 268       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 269
 270       radioButtonsGroup.Add( radioButton );
 271       mLogRadioButtons[2] = radioButton;
 272     }
 273
 274     // Create/delete/disable group
 275     Toolkit::TableView createGroupBackground = Toolkit::TableView::New( 1, 2 );
 276     createGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 277     createGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 278     createGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 279     createGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 280     createGroupBackground.SetFitHeight( 0 );
 281
 282     contentTable.Add( createGroupBackground );
 283
 284     {
 285       Toolkit::PushButton button = Toolkit::PushButton::New();
 286       button.SetName( CREATE_BUTTON_ID );
 287       button.SetLabelText( CREATE_BUTTON_TEXT );
 288       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 289       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 290       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 291
 292       createGroupBackground.Add( button );
 293     }
 294
 295     {
 296       Toolkit::PushButton button = Toolkit::PushButton::New();
 297       button.SetName( DELETE_BUTTON_ID );
 298       button.SetLabelText( DELETE_BUTTON_TEXT );
 299       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 300       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 301       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 302
 303       createGroupBackground.Add( button );
 304     }
 305
 306     // Start/stop group
 307
 308     Toolkit::TableView timingGroupBackground = Toolkit::TableView::New( 1, 2 );
 309     timingGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 310     timingGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 311     timingGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 312     timingGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 313     timingGroupBackground.SetFitHeight( 0 );
 314
 315     contentTable.Add( timingGroupBackground );
 316
 317     {
 318       Toolkit::PushButton button = Toolkit::PushButton::New();
 319       button.SetName( START_BUTTON_ID );
 320       button.SetLabelText( START_BUTTON_TEXT );
 321       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 322       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 323       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 324
 325       timingGroupBackground.Add( button );
 326     }
 327
 328     {
 329       Toolkit::PushButton button = Toolkit::PushButton::New();
 330       button.SetName( STOP_BUTTON_ID );
 331       button.SetLabelText( STOP_BUTTON_TEXT );
 332       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 333       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 334       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 335
 336       timingGroupBackground.Add( button );
 337     }
 338
 339     // Enable/disable group
 340     Toolkit::TableView enableGroupBackground = Toolkit::TableView::New( 1, 2 );
 341     enableGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 342     enableGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 343     enableGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 344     enableGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 345     enableGroupBackground.SetFitHeight( 0 );
 346
 347     contentTable.Add( enableGroupBackground );
 348
 349     {
 350       Toolkit::PushButton button = Toolkit::PushButton::New();
 351       button.SetName( ENABLE_BUTTON_ID );
 352       button.SetLabelText( ENABLE_BUTTON_TEXT );
 353       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 354       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 355       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 356
 357       enableGroupBackground.Add( button );
 358     }
 359
 360     {
 361       Toolkit::PushButton button = Toolkit::PushButton::New();
 362       button.SetName( DISABLE_BUTTON_ID );
 363       button.SetLabelText( DISABLE_BUTTON_TEXT );
 364       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 365       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 366       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 367
 368       enableGroupBackground.Add( button );
 369     }
 370
 371     // Logger selector radio group
 372     Toolkit::TableView frequencyRadioGroupBackground = Toolkit::TableView::New( 2, 1 );
 373     frequencyRadioGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 374     frequencyRadioGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 375     frequencyRadioGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 376     frequencyRadioGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE * 0.5f ) );
 377     frequencyRadioGroupBackground.SetFitHeight( 0 );
 378     frequencyRadioGroupBackground.SetFitHeight( 1 );
 379
 380     contentTable.Add( frequencyRadioGroupBackground );
 381
 382     // Label
 383     {
 384       Toolkit::TextLabel label = Toolkit::TextLabel::New( FREQUENCY_TEXT );
 385
 386       frequencyRadioGroupBackground.Add( label );
 387     }
 388
 389     // Radio group
 390     Toolkit::TableView frequencyRadioButtonsGroup = Toolkit::TableView::New( 1, 3 );
 391     frequencyRadioButtonsGroup.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 392     frequencyRadioButtonsGroup.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 393     frequencyRadioButtonsGroup.SetFitHeight( 0 );
 394     frequencyRadioButtonsGroup.SetPadding( Padding( 0.0f, 0.0f, MARGIN_SIZE, 0.0f ) );
 395
 396     frequencyRadioGroupBackground.Add( frequencyRadioButtonsGroup );
 397
 398     // Radio 1
 399     {
 400       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_1_RADIO_TEXT );
 401       radioButton.SetName( FREQUENCY_1_RADIO_ID );
 402
 403       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 404
 405       frequencyRadioButtonsGroup.Add( radioButton );
 406       mFrequencyRadioButtons[0] = radioButton;
 407     }
 408
 409     // Radio 2
 410     {
 411       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_2_RADIO_TEXT );
 412       radioButton.SetName( FREQUENCY_2_RADIO_ID );
 413
 414       radioButton.SetSelected( true );
 415
 416       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 417
 418       frequencyRadioButtonsGroup.Add( radioButton );
 419       mFrequencyRadioButtons[1] = radioButton;
 420     }
 421
 422     // Radio 3
 423     {
 424       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_3_RADIO_TEXT );
 425       radioButton.SetName( FREQUENCY_3_RADIO_ID );
 426
 427       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 428
 429       frequencyRadioButtonsGroup.Add( radioButton );
 430       mFrequencyRadioButtons[2] = radioButton;
 431     }
 432
 433     // Vsync group
 434     Toolkit::TableView vsyncGroupBackground = Toolkit::TableView::New( 1, 1 );
 435     vsyncGroupBackground.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 436     vsyncGroupBackground.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 437     vsyncGroupBackground.SetBackgroundColor( BACKGROUND_COLOUR );
 438     vsyncGroupBackground.SetCellPadding( Size( MARGIN_SIZE, MARGIN_SIZE ) );
 439     vsyncGroupBackground.SetFitHeight( 0 );
 440
 441     contentTable.Add( vsyncGroupBackground );
 442
 443     {
 444       Toolkit::PushButton button = Toolkit::PushButton::New();
 445       button.SetName( VSYNC_BUTTON_ID );
 446       button.SetLabelText( VSYNC_BUTTON_TEXT );
 447       button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 448       button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
 449       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 450
 451       vsyncGroupBackground.Add( button );
 452     }
 453
 454     WriteConsole();
 455   }
 456
 457   void WriteConsole()
 458   {
 459     for( unsigned int i = 0; i < NUM_LOGGERS; ++i)
 460     {
 461       std::stringstream ss;
 462       ss << (i + 1) << ") " << ((mPerformanceLoggers[i]) ? "Created" : "Deleted")
 463          << ", " << ((mLoggerStates[i].isTiming) ? "Started" : "Stopped")
 464          << ", " << ((mLoggerStates[i].isEnabled) ? "Enabled" : "Disabled");
 465
 466       mLogRadioButtons[i].SetLabelText( ss.str() );
 467     }
 468   }
 469
 470   bool LoggingRadioSelect( Toolkit::Button button )
 471   {
 472     if( button.GetName() == LOGGER_1_RADIO_ID && button.IsSelected() == true )
 473     {
 474       mCurrentLogger = 0;
 475     }
 476     else if( button.GetName() == LOGGER_2_RADIO_ID && button.IsSelected() == true )
 477     {
 478       mCurrentLogger = 1;
 479     }
 480     else if( button.GetName() == LOGGER_3_RADIO_ID && button.IsSelected() == true )
 481     {
 482       mCurrentLogger = 2;
 483     }
 484
 485     UpdateState();
 486
 487     return true;
 488   }
 489
 490   void UpdateState()
 491   {
 492     DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 493     const unsigned int frequency = mLoggerStates[mCurrentLogger].frequency;
 494     if( frequency == HIGH_FREQUENCY )
 495     {
 496       mFrequencyRadioButtons[0].SetSelected( true );
 497     }
 498     else if( frequency == MEDIUM_FREQUENCY )
 499     {
 500       mFrequencyRadioButtons[1].SetSelected( true );
 501     }
 502     else if( frequency == LOW_FREQUENCY )
 503     {
 504       mFrequencyRadioButtons[2].SetSelected( true );
 505     }
 506   }
 507
 508   bool FrequencyRadioSelect( Toolkit::Button button )
 509   {
 510     if( button.GetName() == FREQUENCY_1_RADIO_ID && button.IsSelected() == true )
 511     {
 512       if( mPerformanceLoggers[mCurrentLogger] )
 513       {
 514         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 515         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( HIGH_FREQUENCY );
 516
 517         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 518         mLoggerStates[mCurrentLogger].frequency = HIGH_FREQUENCY;
 519       }
 520     }
 521     else if( button.GetName() == FREQUENCY_2_RADIO_ID && button.IsSelected() == true )
 522     {
 523       if( mPerformanceLoggers[mCurrentLogger] )
 524       {
 525         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 526         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( MEDIUM_FREQUENCY );
 527
 528         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 529         mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 530       }
 531     }
 532     else if( button.GetName() == FREQUENCY_3_RADIO_ID && button.IsSelected() == true )
 533     {
 534       if( mPerformanceLoggers[mCurrentLogger] )
 535       {
 536         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 537         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( LOW_FREQUENCY );
 538
 539         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 540         mLoggerStates[mCurrentLogger].frequency = LOW_FREQUENCY;
 541       }
 542     }
 543
 544     return true;
 545   }
 546
 547   void OnKeyEvent( const KeyEvent& event )
 548   {
 549     if( event.state == KeyEvent::Down )
 550     {
 551       if( IsKey( event, Dali::DALI_KEY_ESCAPE ) || IsKey( event, Dali::DALI_KEY_BACK ) )
 552       {
 553         // Exit application when click back or escape.
 554         mApplication.Quit();
 555       }
 556     }
 557   }
 558
 559   bool OnButtonClicked(Toolkit::Button button)
 560   {
 561     if( button.GetName() == CREATE_BUTTON_ID )
 562     {
 563       std::stringstream ss;
 564       ss << "Test logger " << (mCurrentLogger + 1);
 565
 566       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggerNames.size() );
 567       mPerformanceLoggerNames[mCurrentLogger] = ss.str();
 568
 569       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 570       mPerformanceLoggers[mCurrentLogger] = Dali::PerformanceLogger::New( mPerformanceLoggerNames[mCurrentLogger].c_str() );
 571
 572       DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 573       mLoggerStates[mCurrentLogger].isTiming = false;
 574       mLoggerStates[mCurrentLogger].isEnabled = true;
 575       mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 576
 577       UpdateState();
 578     }
 579     else if ( button.GetName() == DELETE_BUTTON_ID )
 580     {
 581       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 582       mPerformanceLoggers[mCurrentLogger].Reset();
 583
 584       DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 585       mLoggerStates[mCurrentLogger].isTiming = false;
 586       mLoggerStates[mCurrentLogger].isEnabled = true;
 587       mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 588
 589       UpdateState();
 590     }
 591     else if ( button.GetName() == START_BUTTON_ID )
 592     {
 593       if( mPerformanceLoggers[mCurrentLogger] )
 594       {
 595         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 596         mPerformanceLoggers[mCurrentLogger].AddMarker( Dali::PerformanceLogger::START_EVENT );
 597
 598         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 599         mLoggerStates[mCurrentLogger].isTiming = true;
 600       }
 601     }
 602     else if ( button.GetName() == STOP_BUTTON_ID )
 603     {
 604       if( mPerformanceLoggers[mCurrentLogger] )
 605       {
 606         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 607         mPerformanceLoggers[mCurrentLogger].AddMarker( Dali::PerformanceLogger::END_EVENT );
 608
 609         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 610         mLoggerStates[mCurrentLogger].isTiming = false;
 611       }
 612     }
 613     else if ( button.GetName() == ENABLE_BUTTON_ID )
 614     {
 615       if( mPerformanceLoggers[mCurrentLogger] )
 616       {
 617         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 618         mPerformanceLoggers[mCurrentLogger].EnableLogging( true );
 619
 620         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 621         mLoggerStates[mCurrentLogger].isEnabled = true;
 622       }
 623     }
 624     else if ( button.GetName() == DISABLE_BUTTON_ID )
 625     {
 626       if( mPerformanceLoggers[mCurrentLogger] )
 627       {
 628         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 629         mPerformanceLoggers[mCurrentLogger].EnableLogging( false );
 630
 631         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 632         mLoggerStates[mCurrentLogger].isEnabled = false;
 633       }
 634     }
 635
 636     WriteConsole();
 637
 638     return true;
 639   }
 640
 641 private:
 642
 643   struct LoggerState
 644   {
 645     LoggerState() : frequency( 0 ), isTiming( false ), isEnabled( true ) {}
 646
 647     unsigned int frequency;
 648     bool isTiming;
 649     bool isEnabled;
 650   };
 651
 652   Application&      mApplication;
 653   Toolkit::Control  mView;                   ///< The View instance.
 654   Toolkit::ToolBar  mToolBar;                ///< The View's Toolbar.
 655   Layer             mContentLayer;           ///< Content layer
 656
 657   Animation      mAnimation;
 658   float          mLastPoint;
 659
 660   typedef std::vector< std::string > Strings;
 661   Strings mPerformanceLoggerNames;
 662
 663   typedef std::vector< Dali::PerformanceLogger > PerformanceLoggers;
 664   PerformanceLoggers mPerformanceLoggers;
 665   unsigned int mCurrentLogger;
 666
 667   typedef std::vector< LoggerState > LoggerStates;
 668   LoggerStates mLoggerStates;
 669
 670   typedef std::vector< Toolkit::RadioButton > RadioButtons;
 671   RadioButtons mLogRadioButtons;
 672   RadioButtons mFrequencyRadioButtons;
 673 };
 674
 675 void RunTest( Application& application )
 676 {
 677   LoggingController test( application );
 678
 679   application.MainLoop();
 680 }
 681
 682 // Entry point for Linux & Tizen applications
 683 //
 684 int DALI_EXPORT_API main( int argc, char **argv )
 685 {
 686   Application application = Application::New( &argc, &argv, DEMO_THEME_PATH );
 687
 688   RunTest( application );
 689
 690   return 0;
 691 }