dali-toolkit/internal/feedback/feedback-style.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 // CLASS HEADER
  19 #include <dali-toolkit/internal/feedback/feedback-style.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/common/stage.h>
  24 #include <dali/public-api/object/object-registry.h>
  25 #include <dali/devel-api/adaptor-framework/style-monitor.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/devel-api/builder/json-parser.h>
  29 #include <dali-toolkit/internal/feedback/feedback-ids.h>
  30
  31 using std::string;
  32
  33 namespace // unnamed namespace
  34 {
  35
  36 #if defined(DEBUG_ENABLED)
  37 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::General, false, "LOG_FEEDBACK");
  38 #endif
  39
  40 const char* DEFAULT_FEEDBACK_THEME_PATH = DALI_STYLE_DIR"default-feedback-theme.json";
  41
  42 // Sets bool and string if the node has a child "name"
  43 void GetIfString(const Dali::Toolkit::TreeNode& node, const std::string& name, bool& exists, std::string& str)
  44 {
  45   const Dali::Toolkit::TreeNode* child = node.GetChild(name);
  46   if( child &&
  47       Dali::Toolkit::TreeNode::STRING == child->GetType() )
  48   {
  49     exists = true;
  50     str = child->GetString();
  51   }
  52 }
  53
  54 } // unnamed namespace
  55
  56 namespace Dali
  57 {
  58
  59 namespace Toolkit
  60 {
  61
  62 namespace Internal
  63 {
  64
  65 struct SignalFeedbackInfo
  66 {
  67   /**
  68    * Default constructor.
  69    */
  70   SignalFeedbackInfo()
  71   :mHasHapticFeedbackInfo(false),
  72    mHasSoundFeedbackInfo(false)
  73   {
  74   }
  75
  76   bool mHasHapticFeedbackInfo;
  77   bool mHasSoundFeedbackInfo;
  78   string mSignalName;
  79   string mHapticFeedbackPattern;
  80   string mSoundFeedbackPattern;
  81   string mHapticFeedbackFile;
  82   string mSoundFeedbackFile;
  83 };
  84
  85 typedef std::vector<SignalFeedbackInfo> SignalFeedbackInfoContainer;
  86 typedef SignalFeedbackInfoContainer::const_iterator SignalFeedbackInfoConstIter;
  87
  88 struct FeedbackStyleInfo
  89 {
  90   /**
  91    * Default constructor.
  92    */
  93   FeedbackStyleInfo()
  94   {
  95   }
  96
  97   string mTypeName;
  98
  99   SignalFeedbackInfoContainer mSignalFeedbackInfoList;
 100 };
 101
 102 static const FeedbackStyleInfo DEFAULT_FEEDBACK_STYLE_INFO;
 103
 104 FeedbackStyle::FeedbackStyle()
 105 : mConnections( this )
 106 {
 107   mFeedback = Dali::FeedbackPlayer::Get();
 108
 109   string defaultTheme;
 110
 111   if( mFeedback && mFeedback.LoadFile( DEFAULT_FEEDBACK_THEME_PATH, defaultTheme ) )
 112   {
 113     LoadTheme( defaultTheme );
 114     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceLoader::LoadTheme(%s) - loaded %d bytes\n",
 115                    DEFAULT_FEEDBACK_THEME_PATH, defaultTheme.size() );
 116   }
 117   else
 118   {
 119     DALI_LOG_ERROR("ResourceLoader::LoadTheme(%s) - failed to load\n", DEFAULT_FEEDBACK_THEME_PATH);
 120   }
 121
 122 }
 123
 124 FeedbackStyle::~FeedbackStyle()
 125 {
 126 }
 127
 128 struct PlayFeedbackFromSignal
 129 {
 130   PlayFeedbackFromSignal( FeedbackStyle& controller, const string& typeName, const string& signalName )
 131   : mController( controller ),
 132     mTypeName( typeName ),
 133     mSignalName( signalName )
 134   {
 135   }
 136
 137   void operator()()
 138   {
 139     mController.PlayFeedback( mTypeName, mSignalName );
 140   }
 141
 142   FeedbackStyle& mController;
 143   string mTypeName;
 144   string mSignalName;
 145 };
 146
 147
 148 void FeedbackStyle::ObjectCreated( BaseHandle handle )
 149 {
 150   std::string typeName = handle.GetTypeName();
 151
 152   if( handle )
 153   {
 154     string type = handle.GetTypeName();
 155
 156     const FeedbackStyleInfo styleInfo = GetStyleInfo( type );
 157
 158     for( SignalFeedbackInfoConstIter iter = styleInfo.mSignalFeedbackInfoList.begin(); iter != styleInfo.mSignalFeedbackInfoList.end(); ++iter )
 159     {
 160       const SignalFeedbackInfo& info = *iter;
 161
 162       if( info.mHasHapticFeedbackInfo || info.mHasSoundFeedbackInfo )
 163       {
 164         if( !info.mHapticFeedbackPattern.empty() || !info.mHapticFeedbackFile.empty() ||
 165             !info.mSoundFeedbackPattern.empty()  || !info.mSoundFeedbackFile.empty() )
 166         {
 167           handle.ConnectSignal( this,
 168                                 info.mSignalName,
 169                                 PlayFeedbackFromSignal( *this, type, info.mSignalName ) );
 170
 171           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "FeedbackStyle::Set found Haptic pattern %s for Object type: %s, Signal Type: %s\n",
 172                          info.mHapticFeedbackPattern.c_str(), type.c_str(), info.mSignalName.c_str() );
 173         }
 174         else
 175         {
 176           DALI_LOG_ERROR("FeedbackStyle::Set() Warning Inconsistent data in theme file!\n");
 177         }
 178       }
 179     }
 180   }
 181 }
 182
 183 const FeedbackStyleInfo& FeedbackStyle::GetStyleInfo( const string& type ) const
 184 {
 185   std::map<const string, FeedbackStyleInfo>::const_iterator iter( mStyleInfoLut.find( type ) );
 186   if( iter != mStyleInfoLut.end() )
 187   {
 188     return iter->second;
 189   }
 190   else
 191   {
 192     return DEFAULT_FEEDBACK_STYLE_INFO;
 193   }
 194 }
 195
 196 void FeedbackStyle::StyleChanged( const std::string& userDefinedThemePath, Dali::StyleChange::Type styleChange )
 197 {
 198   if( StyleChange::THEME_CHANGE )
 199   {
 200     string userDefinedTheme;
 201
 202     if( mFeedback && mFeedback.LoadFile( userDefinedThemePath, userDefinedTheme ) )
 203     {
 204       if( !LoadTheme( userDefinedTheme ) )
 205       {
 206         DALI_LOG_ERROR("FeedbackStyle::StyleChanged() User defined theme failed to load! \n");
 207
 208         //If there is any problem is using the user defined theme, then fall back to default theme
 209         if( !LoadTheme( DEFAULT_FEEDBACK_THEME_PATH ) )
 210         {
 211           //If the default theme fails, Then No luck!
 212           DALI_LOG_ERROR("FeedbackStyle::StyleChanged() Default theme failed to load! \n");
 213         }
 214       }
 215       else
 216       {
 217         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceLoader::LoadTheme(%s) - loaded %d bytes\n",
 218                        userDefinedThemePath.c_str(), userDefinedTheme.size() );
 219       }
 220     }
 221     else
 222     {
 223       DALI_LOG_ERROR("ResourceLoader::LoadTheme(%s) - failed to load\n", userDefinedThemePath.c_str());
 224     }
 225   }
 226 }
 227
 228 bool FeedbackStyle::LoadTheme( const string& data )
 229 {
 230   bool result = false;
 231
 232   try
 233   {
 234     LoadFromString( data );
 235
 236     result = true;
 237   }
 238   catch(...)
 239   {
 240     //Problem in user set theme, So fallback to use default theme.
 241     DALI_LOG_ERROR( "FeedbackStyle::LoadTheme() Failed to load theme\n" );
 242   }
 243
 244   return result;
 245 }
 246
 247 void FeedbackStyle::LoadFromString( const string& data )
 248 {
 249   Toolkit::JsonParser parser = Toolkit::JsonParser::New();
 250   const Toolkit::TreeNode* root = NULL;
 251
 252   if( !parser.Parse( data ) )
 253   {
 254     DALI_LOG_WARNING( "JSON Parse Error:'%s'\n", parser.GetErrorDescription().c_str() );
 255     DALI_LOG_WARNING( "JSON Parse Line :'%d (%d)'\n",
 256                       parser.GetErrorLineNumber(),
 257                       parser.GetErrorColumn() );
 258   }
 259   else
 260   {
 261     root = parser.GetRoot();
 262   }
 263
 264   if(root)
 265   {
 266     // Clear previously loaded style
 267     mStyleInfoLut.clear();
 268
 269     // Parse style
 270     if( const TreeNode* node = root->GetChild("style") )
 271     {
 272       Toolkit::TreeNode::ConstIterator iter = node->CBegin();
 273       Toolkit::TreeNode::ConstIterator end = node->CEnd();
 274       for( ; iter != end; ++iter )
 275       {
 276         const char* key = (*iter).first;
 277         FeedbackStyleInfo themeInfo;
 278         themeInfo.mTypeName = key;
 279
 280         if( const TreeNode* signals = (*iter).second.GetChild("signals") )
 281         {
 282           TreeNode::ConstIterator signalIter = signals->CBegin();
 283           TreeNode::ConstIterator signalEnd = signals->CEnd();
 284           for( ; signalIter != signalEnd; ++signalIter )
 285           {
 286             SignalFeedbackInfo signalFeedbackInfo;
 287
 288             const TreeNode* type = (*signalIter).second.GetChild("type");
 289             DALI_ASSERT_ALWAYS(type && TreeNode::STRING == type->GetType() && "Signal must have a type");
 290             signalFeedbackInfo.mSignalName = type->GetString();
 291
 292             GetIfString( (*signalIter).second, "haptic-feedback-pattern",
 293                          signalFeedbackInfo.mHasHapticFeedbackInfo,
 294                          signalFeedbackInfo.mHapticFeedbackPattern );
 295
 296             GetIfString( (*signalIter).second, "haptic-feedback-file",
 297                          signalFeedbackInfo.mHasHapticFeedbackInfo,
 298                          signalFeedbackInfo.mHapticFeedbackFile );
 299
 300             GetIfString( (*signalIter).second, "sound-feedback-pattern",
 301                          signalFeedbackInfo.mHasSoundFeedbackInfo,
 302                          signalFeedbackInfo.mSoundFeedbackPattern );
 303
 304             GetIfString( (*signalIter).second, "haptic-feedback-file",
 305                          signalFeedbackInfo.mHasSoundFeedbackInfo,
 306                          signalFeedbackInfo.mSoundFeedbackFile );
 307
 308             if( signalFeedbackInfo.mHasHapticFeedbackInfo || signalFeedbackInfo.mHasSoundFeedbackInfo )
 309             {
 310               AddSignalInfo( themeInfo, signalFeedbackInfo );
 311             }
 312           }
 313         }
 314
 315         mStyleInfoLut[key] = themeInfo;
 316
 317       } // for styles
 318     } // if(style)
 319   } // if(root)
 320
 321 } // LoadFromString()
 322
 323 void FeedbackStyle::AddSignalInfo( FeedbackStyleInfo& styleInfo, SignalFeedbackInfo signalInfo )
 324 {
 325   bool updated = false;
 326   std::vector<SignalFeedbackInfo>::iterator iter;
 327
 328   // If info exists for the signal then update it, else add new
 329   for( iter = styleInfo.mSignalFeedbackInfoList.begin(); iter != styleInfo.mSignalFeedbackInfoList.end(); ++iter )
 330   {
 331     if( (*iter).mSignalName == signalInfo.mSignalName )
 332     {
 333       (*iter).mHasHapticFeedbackInfo = signalInfo.mHasHapticFeedbackInfo;
 334       (*iter).mHapticFeedbackPattern = signalInfo.mHapticFeedbackPattern;
 335       (*iter).mHapticFeedbackFile    = signalInfo.mHapticFeedbackFile;
 336       (*iter).mHasSoundFeedbackInfo  = signalInfo.mHasSoundFeedbackInfo;
 337       (*iter).mSoundFeedbackPattern  = signalInfo.mSoundFeedbackPattern;
 338       (*iter).mSoundFeedbackFile     = signalInfo.mSoundFeedbackFile;
 339
 340       updated = true;
 341       break;
 342     }
 343   }
 344
 345   if( !updated )
 346   {
 347     styleInfo.mSignalFeedbackInfoList.push_back( signalInfo );
 348   }
 349 }
 350
 351 void FeedbackStyle::PlayFeedback(const string& type, const string& signalName)
 352 {
 353   const FeedbackStyleInfo styleInfo = GetStyleInfo(type);
 354   SignalFeedbackInfoConstIter iter;
 355
 356   for(iter = styleInfo.mSignalFeedbackInfoList.begin(); iter != styleInfo.mSignalFeedbackInfoList.end(); ++iter)
 357   {
 358     const SignalFeedbackInfo& info = *iter;
 359
 360     if(info.mSignalName == signalName)
 361     {
 362       if(info.mHasHapticFeedbackInfo)
 363       {
 364         if(!info.mHapticFeedbackPattern.empty())
 365         {
 366           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "FeedbackStyle::PlayFeedback Playing Haptic effect: Object type: %s, Signal type: %s, pattern type: %s\n",
 367               type.c_str(), signalName.c_str(), info.mHapticFeedbackPattern.c_str());
 368
 369           mFeedback.PlayFeedbackPattern( FEEDBACK_TYPE_VIBRATION, GetFeedbackPattern(info.mHapticFeedbackPattern) );
 370         }
 371         else if(!info.mHapticFeedbackFile.empty())
 372         {
 373           mFeedback.PlayFile( info.mHapticFeedbackFile );
 374         }
 375       }
 376
 377       if(info.mHasSoundFeedbackInfo)
 378       {
 379         if(!info.mSoundFeedbackPattern.empty())
 380         {
 381           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "FeedbackStyle::PlayFeedback Playing Sound effect: Object type: %s, Signal type: %s, pattern type: %s\n",
 382               type.c_str(), signalName.c_str(), info.mHapticFeedbackPattern.c_str());
 383
 384           mFeedback.PlayFeedbackPattern( FEEDBACK_TYPE_SOUND, GetFeedbackPattern(info.mSoundFeedbackPattern) );
 385         }
 386         else if(!info.mSoundFeedbackFile.empty())
 387         {
 388           mFeedback.PlaySound( info.mSoundFeedbackFile );
 389         }
 390       }
 391
 392       break;
 393     }
 394   }
 395 }
 396
 397 FeedbackPattern FeedbackStyle::GetFeedbackPattern( const string &pattern )
 398 {
 399   if( 0 == mFeedbackPatternLut.size() )
 400   {
 401     mFeedbackPatternLut["FEEDBACK_PATTERN_NONE"]                = Dali::FEEDBACK_PATTERN_NONE;
 402     mFeedbackPatternLut["FEEDBACK_PATTERN_TAP"]                 = Dali::FEEDBACK_PATTERN_TAP;
 403     mFeedbackPatternLut["FEEDBACK_PATTERN_SIP"]                 = Dali::FEEDBACK_PATTERN_SIP;
 404     mFeedbackPatternLut["FEEDBACK_PATTERN_SIP_BACKSPACE"]       = Dali::FEEDBACK_PATTERN_SIP_BACKSPACE;
 405     mFeedbackPatternLut["FEEDBACK_PATTERN_MAX_CHARACTER"]       = Dali::FEEDBACK_PATTERN_MAX_CHARACTER;
 406     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY0"]                = Dali::FEEDBACK_PATTERN_KEY0;
 407     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY1"]                = Dali::FEEDBACK_PATTERN_KEY1;
 408     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY2"]                = Dali::FEEDBACK_PATTERN_KEY2;
 409     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY3"]                = Dali::FEEDBACK_PATTERN_KEY3;
 410     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY4"]                = Dali::FEEDBACK_PATTERN_KEY4;
 411     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY5"]                = Dali::FEEDBACK_PATTERN_KEY5;
 412     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY6"]                = Dali::FEEDBACK_PATTERN_KEY6;
 413     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY7"]                = Dali::FEEDBACK_PATTERN_KEY7;
 414     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY8"]                = Dali::FEEDBACK_PATTERN_KEY8;
 415     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY9"]                = Dali::FEEDBACK_PATTERN_KEY9;
 416     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY_STAR"]            = Dali::FEEDBACK_PATTERN_KEY_STAR;
 417     mFeedbackPatternLut["FEEDBACK_PATTERN_KEY_SHARP"]           = Dali::FEEDBACK_PATTERN_KEY_SHARP;
 418     mFeedbackPatternLut["FEEDBACK_PATTERN_HOLD"]                = Dali::FEEDBACK_PATTERN_HOLD;
 419     mFeedbackPatternLut["FEEDBACK_PATTERN_MULTI_TAP"]           = Dali::FEEDBACK_PATTERN_MULTI_TAP;
 420     mFeedbackPatternLut["FEEDBACK_PATTERN_HW_TAP"]              = Dali::FEEDBACK_PATTERN_HW_TAP;
 421     mFeedbackPatternLut["FEEDBACK_PATTERN_HW_HOLD"]             = Dali::FEEDBACK_PATTERN_HW_HOLD;
 422     mFeedbackPatternLut["FEEDBACK_PATTERN_MESSAGE"]             = Dali::FEEDBACK_PATTERN_MESSAGE;
 423     mFeedbackPatternLut["FEEDBACK_PATTERN_MESSAGE_ON_CALL"]     = Dali::FEEDBACK_PATTERN_MESSAGE_ON_CALL;
 424     mFeedbackPatternLut["FEEDBACK_PATTERN_EMAIL"]               = Dali::FEEDBACK_PATTERN_EMAIL;
 425     mFeedbackPatternLut["FEEDBACK_PATTERN_EMAIL_ON_CALL"]       = Dali::FEEDBACK_PATTERN_EMAIL_ON_CALL;
 426     mFeedbackPatternLut["FEEDBACK_PATTERN_WAKEUP"]              = Dali::FEEDBACK_PATTERN_WAKEUP;
 427     mFeedbackPatternLut["FEEDBACK_PATTERN_WAKEUP_ON_CALL"]      = Dali::FEEDBACK_PATTERN_WAKEUP_ON_CALL;
 428     mFeedbackPatternLut["FEEDBACK_PATTERN_SCHEDULE"]            = Dali::FEEDBACK_PATTERN_SCHEDULE;
 429     mFeedbackPatternLut["FEEDBACK_PATTERN_SCHEDULE_ON_CALL"]    = Dali::FEEDBACK_PATTERN_SCHEDULE_ON_CALL;
 430     mFeedbackPatternLut["FEEDBACK_PATTERN_TIMER"]               = Dali::FEEDBACK_PATTERN_TIMER;
 431     mFeedbackPatternLut["FEEDBACK_PATTERN_TIMER_ON_CALL"]       = Dali::FEEDBACK_PATTERN_TIMER_ON_CALL;
 432     mFeedbackPatternLut["FEEDBACK_PATTERN_GENERAL"]             = Dali::FEEDBACK_PATTERN_GENERAL;
 433     mFeedbackPatternLut["FEEDBACK_PATTERN_GENERAL_ON_CALL"]     = Dali::FEEDBACK_PATTERN_GENERAL_ON_CALL;
 434     mFeedbackPatternLut["FEEDBACK_PATTERN_POWER_ON"]            = Dali::FEEDBACK_PATTERN_POWER_ON;
 435     mFeedbackPatternLut["FEEDBACK_PATTERN_POWER_OFF"]           = Dali::FEEDBACK_PATTERN_POWER_OFF;
 436     mFeedbackPatternLut["FEEDBACK_PATTERN_CHARGERCONN"]         = Dali::FEEDBACK_PATTERN_CHARGERCONN;
 437     mFeedbackPatternLut["FEEDBACK_PATTERN_CHARGERCONN_ON_CALL"] = Dali::FEEDBACK_PATTERN_CHARGERCONN_ON_CALL;
 438     mFeedbackPatternLut["FEEDBACK_PATTERN_FULLCHARGED"]         = Dali::FEEDBACK_PATTERN_FULLCHARGED;
 439     mFeedbackPatternLut["FEEDBACK_PATTERN_FULLCHARGED_ON_CALL"] = Dali::FEEDBACK_PATTERN_FULLCHARGED_ON_CALL;
 440     mFeedbackPatternLut["FEEDBACK_PATTERN_LOWBATT"]             = Dali::FEEDBACK_PATTERN_LOWBATT;
 441     mFeedbackPatternLut["FEEDBACK_PATTERN_LOWBATT_ON_CALL"]     = Dali::FEEDBACK_PATTERN_LOWBATT_ON_CALL;
 442     mFeedbackPatternLut["FEEDBACK_PATTERN_LOCK"]                = Dali::FEEDBACK_PATTERN_LOCK;
 443     mFeedbackPatternLut["FEEDBACK_PATTERN_UNLOCK"]              = Dali::FEEDBACK_PATTERN_UNLOCK;
 444     mFeedbackPatternLut["FEEDBACK_PATTERN_CALLCONNECT"]         = Dali::FEEDBACK_PATTERN_CALLCONNECT;
 445     mFeedbackPatternLut["FEEDBACK_PATTERN_DISCALLCONNECT"]      = Dali::FEEDBACK_PATTERN_DISCALLCONNECT;
 446     mFeedbackPatternLut["FEEDBACK_PATTERN_MINUTEMINDER"]        = Dali::FEEDBACK_PATTERN_MINUTEMINDER;
 447     mFeedbackPatternLut["FEEDBACK_PATTERN_VIBRATION"]           = Dali::FEEDBACK_PATTERN_VIBRATION;
 448     mFeedbackPatternLut["FEEDBACK_PATTERN_SHUTTER"]             = Dali::FEEDBACK_PATTERN_SHUTTER;
 449     mFeedbackPatternLut["FEEDBACK_PATTERN_LIST_REORDER"]        = Dali::FEEDBACK_PATTERN_LIST_REORDER;
 450     mFeedbackPatternLut["FEEDBACK_PATTERN_SLIDER_SWEEP"]        = Dali::FEEDBACK_PATTERN_SLIDER_SWEEP;
 451   }
 452
 453   std::map<const string, FeedbackPattern>::const_iterator iter( mFeedbackPatternLut.find( pattern ) );
 454
 455   if( iter != mFeedbackPatternLut.end() )
 456   {
 457     return iter->second;
 458   }
 459   else
 460   {
 461     DALI_LOG_ERROR( "Unknown feedback pattern type: %s, So Defaulting to FEEDBACK_PATTERN_NONE!\n" );
 462     return Dali::FEEDBACK_PATTERN_NONE;
 463   }
 464 }
 465
 466 } // namespace Toolkit
 467
 468 } // namespace Internal
 469
 470 } // namespace Dali