automated-tests/src/dali/dali-test-suite-utils/test-addon-manager.cpp

   1 /*
   2  * Copyright (c) 2020 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 "test-addon-manager.h"
  19
  20 #include <dali-test-suite-utils.h>
  21 #include <dlfcn.h>
  22
  23 #include <cstring>
  24
  25 #ifndef ADDON_LIBS_PATH
  26 #define ADDON_LIBS_PATH ""
  27 #endif
  28
  29 namespace Dali
  30 {
  31 namespace Test
  32 {
  33 std::vector<std::string> AddOnManager::EnumerateAddOns()
  34 {
  35   std::string listFileName(ADDON_LIBS_PATH);
  36   listFileName += "/addons.txt";
  37
  38   // Read list of available test addons
  39   tet_printf("Enumerating addons, file: %s\n", listFileName.c_str());
  40   std::vector<std::string> addons{};
  41   auto*                    fin     = fopen(listFileName.c_str(), "r");
  42   char*                    lineBuf = new char[256];
  43   size_t                   n       = 256;
  44   while(getline(&lineBuf, &n, fin) > 0)
  45   {
  46     tet_printf("Adding %s\n", lineBuf);
  47     addons.emplace_back(lineBuf);
  48   }
  49   fclose(fin);
  50   delete[] lineBuf;
  51   std::vector<std::string> retval{};
  52   // Open addons
  53   for(auto& name : addons)
  54   {
  55     std::string path(ADDON_LIBS_PATH);
  56     path += "/";
  57     path += name;
  58
  59     mAddOnCache.emplace_back();
  60     mAddOnCache.back().handle = dlopen(path.c_str(), RTLD_DEEPBIND | RTLD_LAZY);
  61     if(!mAddOnCache.back().handle)
  62     {
  63       mAddOnCache.back().valid = false;
  64       tet_printf("Can't open addon lib: %s\n", path.c_str());
  65       continue;
  66     }
  67     // Here addon must self register
  68     if(!mAddOnCache.back().valid)
  69     {
  70       puts("Addon invalid!");
  71     }
  72     else
  73     {
  74       tet_printf("Valid AddOn: %s\n", mAddOnCache.back().name.c_str());
  75       retval.emplace_back(mAddOnCache.back().name);
  76     }
  77   }
  78
  79   return retval;
  80
  81   /**
  82    * Check for self-registering addons
  83    */
  84 }
  85
  86 void AddOnManager::RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable)
  87 {
  88   // Register the dispatch table
  89   auto& entry = mAddOnCache.back();
  90   entry.name  = dispatchTable->name;
  91   tet_printf("Registering AddOn: %s\n", entry.name.c_str());
  92   entry.GetGlobalProc   = dispatchTable->GetGlobalProc;
  93   entry.GetInstanceProc = dispatchTable->GetInstanceProc;
  94   entry.GetAddOnInfo    = dispatchTable->GetAddOnInfo;
  95   entry.OnStart         = dispatchTable->OnStart;
  96   entry.OnStop          = dispatchTable->OnStop;
  97   entry.OnPause         = dispatchTable->OnPause;
  98   entry.OnResume        = dispatchTable->OnResume;
  99   entry.valid           = true;
 100 }
 101
 102 bool AddOnManager::GetAddOnInfo(const std::string& name, AddOnInfo& info)
 103 {
 104   auto retval = false;
 105   std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &info](AddOnCacheEntry& entry) {
 106     if(entry.name == name)
 107     {
 108       entry.GetAddOnInfo(info);
 109       retval = true;
 110       return true;
 111     }
 112     return false;
 113   });
 114   return retval;
 115 }
 116
 117 std::vector<AddOnLibrary> AddOnManager::LoadAddOns(const std::vector<std::string>& addonNames)
 118 {
 119   if(mAddOnCache.empty())
 120   {
 121     EnumerateAddOns();
 122   }
 123
 124   std::vector<AddOnLibrary> retval{};
 125   for(auto& name : addonNames)
 126   {
 127     size_t index = 0;
 128     auto   iter  = std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &index](AddOnCacheEntry& entry) {
 129       index++;
 130       if(entry.name == name)
 131       {
 132         return true;
 133       }
 134       return false;
 135     });
 136     if(iter != mAddOnCache.end())
 137     {
 138       retval.emplace_back(*reinterpret_cast<void**>(&index));
 139     }
 140     else
 141     {
 142       retval.emplace_back(nullptr);
 143     }
 144   }
 145
 146   return retval;
 147 }
 148
 149 void* AddOnManager::GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
 150 {
 151   auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
 152   return mAddOnCache[index - 1].GetGlobalProc(procName);
 153 }
 154
 155 void* AddOnManager::GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
 156 {
 157   auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
 158   return mAddOnCache[index - 1].GetInstanceProc(procName);
 159 }
 160
 161 void AddOnManager::Start()
 162 {
 163   for(auto& entry : mAddOnCache)
 164   {
 165     if(entry.OnStart)
 166     {
 167       entry.OnStart();
 168     }
 169   }
 170 }
 171
 172 void AddOnManager::Resume()
 173 {
 174   for(auto& entry : mAddOnCache)
 175   {
 176     if(entry.OnResume)
 177     {
 178       entry.OnResume();
 179     }
 180   }
 181 }
 182
 183 void AddOnManager::Stop()
 184 {
 185   for(auto& entry : mAddOnCache)
 186   {
 187     if(entry.OnStop)
 188     {
 189       entry.OnStop();
 190     }
 191   }
 192 }
 193
 194 void AddOnManager::Pause()
 195 {
 196   for(auto& entry : mAddOnCache)
 197   {
 198     if(entry.OnPause)
 199     {
 200       entry.OnPause();
 201     }
 202   }
 203 }
 204
 205 } // namespace Test
 206 } // namespace Dali