blob: 466844d8eee4512c9da26fb9f3dd391dc68c61ea [file] [log] [blame]
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __PLUGIN_MANAGER_H__
#define __PLUGIN_MANAGER_H__
#include <dlfcn.h>
#include <sys/types.h>
#include <dirent.h>
#include <utils/String8.h>
#include <utils/Vector.h>
#include <utils/KeyedVector.h>
namespace android {
const char* const PLUGIN_MANAGER_CREATE = "create";
const char* const PLUGIN_MANAGER_DESTROY = "destroy";
const char* const PLUGIN_EXTENSION = ".so";
/**
* This is the template class for Plugin manager.
*
* The DrmManager uses this class to handle the plugins.
*
*/
template<typename Type>
class TPlugInManager {
private:
typedef void* HANDLE;
typedef Type* create_t(void);
typedef void destroy_t(Type*);
typedef create_t* FPCREATE;
typedef destroy_t* FPDESTORY;
typedef struct _PlugInContainer {
String8 sPath;
HANDLE hHandle;
FPCREATE fpCreate;
FPDESTORY fpDestory;
Type* pInstance;
_PlugInContainer():
sPath("")
,hHandle(NULL)
,fpCreate(NULL)
,fpDestory(NULL)
,pInstance(NULL)
{}
} PlugInContainer;
typedef KeyedVector<String8, PlugInContainer*> PlugInMap;
PlugInMap m_plugInMap;
typedef Vector<String8> PlugInIdList;
PlugInIdList m_plugInIdList;
public:
/**
* Load all the plug-ins in the specified directory
*
* @param[in] rsPlugInDirPath
* Directory path which plug-ins (dynamic library) are stored
* @note Plug-ins should be implemented according to the specification
*/
void loadPlugIns(const String8& rsPlugInDirPath) {
Vector<String8> plugInFileList = getPlugInPathList(rsPlugInDirPath);
if (!plugInFileList.isEmpty()) {
for (size_t i = 0; i < plugInFileList.size(); ++i) {
loadPlugIn(plugInFileList[i]);
}
}
}
/**
* Unload all the plug-ins
*
*/
void unloadPlugIns() {
for (size_t i = 0; i < m_plugInIdList.size(); ++i) {
unloadPlugIn(m_plugInIdList[i]);
}
m_plugInIdList.clear();
}
/**
* Get all the IDs of available plug-ins
*
* @return[in] plugInIdList
* String type Vector in which all plug-in IDs are stored
*/
Vector<String8> getPlugInIdList() const {
return m_plugInIdList;
}
/**
* Get a plug-in reference of specified ID
*
* @param[in] rsPlugInId
* Plug-in ID to be used
* @return plugIn
* Reference of specified plug-in instance
*/
Type& getPlugIn(const String8& rsPlugInId) {
if (!contains(rsPlugInId)) {
// This error case never happens
}
return *(m_plugInMap.valueFor(rsPlugInId)->pInstance);
}
public:
/**
* Load a plug-in stored in the specified path
*
* @param[in] rsPlugInPath
* Plug-in (dynamic library) file path
* @note Plug-in should be implemented according to the specification
*/
void loadPlugIn(const String8& rsPlugInPath) {
if (contains(rsPlugInPath)) {
return;
}
PlugInContainer* pPlugInContainer = new PlugInContainer();
pPlugInContainer->hHandle = dlopen(rsPlugInPath.string(), RTLD_LAZY);
if (NULL == pPlugInContainer->hHandle) {
delete pPlugInContainer;
pPlugInContainer = NULL;
return;
}
pPlugInContainer->sPath = rsPlugInPath;
pPlugInContainer->fpCreate
= (FPCREATE)dlsym(pPlugInContainer->hHandle, PLUGIN_MANAGER_CREATE);
pPlugInContainer->fpDestory
= (FPDESTORY)dlsym(pPlugInContainer->hHandle, PLUGIN_MANAGER_DESTROY);
if (NULL != pPlugInContainer->fpCreate && NULL != pPlugInContainer->fpDestory) {
pPlugInContainer->pInstance = (Type*)pPlugInContainer->fpCreate();
m_plugInIdList.add(rsPlugInPath);
m_plugInMap.add(rsPlugInPath, pPlugInContainer);
} else {
dlclose(pPlugInContainer->hHandle);
delete pPlugInContainer;
pPlugInContainer = NULL;
return;
}
}
/**
* Unload a plug-in stored in the specified path
*
* @param[in] rsPlugInPath
* Plug-in (dynamic library) file path
*/
void unloadPlugIn(const String8& rsPlugInPath) {
if (!contains(rsPlugInPath)) {
return;
}
PlugInContainer* pPlugInContainer = m_plugInMap.valueFor(rsPlugInPath);
pPlugInContainer->fpDestory(pPlugInContainer->pInstance);
dlclose(pPlugInContainer->hHandle);
m_plugInMap.removeItem(rsPlugInPath);
delete pPlugInContainer;
pPlugInContainer = NULL;
}
private:
/**
* True if TPlugInManager contains rsPlugInId
*/
bool contains(const String8& rsPlugInId) {
return m_plugInMap.indexOfKey(rsPlugInId) != NAME_NOT_FOUND;
}
/**
* Return file path list of plug-ins stored in the specified directory
*
* @param[in] rsDirPath
* Directory path in which plug-ins are stored
* @return plugInFileList
* String type Vector in which file path of plug-ins are stored
*/
Vector<String8> getPlugInPathList(const String8& rsDirPath) {
Vector<String8> fileList;
DIR* pDir = opendir(rsDirPath.string());
struct dirent* pEntry;
while (NULL != pDir && NULL != (pEntry = readdir(pDir))) {
if (!isPlugIn(pEntry)) {
continue;
}
String8 plugInPath;
plugInPath += rsDirPath;
plugInPath += "/";
plugInPath += pEntry->d_name;
fileList.add(plugInPath);
}
if (NULL != pDir) {
closedir(pDir);
}
return fileList;
}
/**
* True if the input name denotes plug-in
*/
bool isPlugIn(const struct dirent* pEntry) const {
String8 sName(pEntry->d_name);
String8 extension(sName.getPathExtension());
// Note that the plug-in extension must exactly match case
return extension == String8(PLUGIN_EXTENSION);
}
/**
* True if input entry is directory
*/
bool isDirectory(const struct dirent* pEntry) const {
return DT_DIR == pEntry->d_type;
}
/**
* True if input entry is regular file
*/
bool isRegularFile(const struct dirent* pEntry) const {
return DT_REG == pEntry->d_type;
}
/**
* True if input entry is link
*/
bool isLink(const struct dirent* pEntry) const {
return DT_LNK == pEntry->d_type;
}
};
};
#endif /* __PLUGIN_MANAGER_H__ */