opluginloader.cpp

Go to the documentation of this file.

/*
 * LGPLv2 or later
 * zecke@handhelds.org
 */

#include "opluginloader.h"
#include "oconfig.h"
#include "odebug.h"

#include <qpe/qpeapplication.h>

#include <qdir.h>
#include <qdict.h>
#include <qtl.h>
#include <qfile.h>

#include <stdlib.h>



namespace Opie {
namespace Core {
namespace Internal {
struct OPluginLibraryHolder {
    static OPluginLibraryHolder *self();
    QLibrary *ref( const QString& );
    void deref( QLibrary* );
private:

    OPluginLibraryHolder();
    ~OPluginLibraryHolder();
    QDict<QLibrary> m_libs;
    static OPluginLibraryHolder* m_self;
};

    OPluginLibraryHolder* OPluginLibraryHolder::m_self  = 0;
    OPluginLibraryHolder* OPluginLibraryHolder::self() {
        if ( !m_self )
            m_self = new OPluginLibraryHolder;

        return m_self;
    }

    OPluginLibraryHolder::OPluginLibraryHolder() {}
    OPluginLibraryHolder::~OPluginLibraryHolder() {}

    /*
     * We do simple ref counting... We will add the QLibrary again
     * and again to the dictionary and on deref we will pop and pop it
     * until there are no more library and we will unload and delete the library
     * luckily dlopen does some ref counting as well so we don't need
     * to hack QPEApplication
     */
    QLibrary* OPluginLibraryHolder::ref(const QString& str) {
        QLibrary *lib = m_libs[str];

        /* if not in the dict try to load it */
        if ( !lib ) {
            lib = new QLibrary( str, QLibrary::Immediately );
            if ( !lib->isLoaded() ) {
                delete lib;
                return 0l;
            }
        }

        /* now refcount one up */
        m_libs.insert( str, lib );
        return lib;
    }

    /*
     * 'unshadow' the items until we're the last then unload and delete
     */
    void OPluginLibraryHolder::deref( QLibrary* lib ) {
        if ( !lib )
            return;

        QString str = lib->library();
        /* no need to check if the lib was inserted or such */
        (void) m_libs.take( str );
        if ( !m_libs[str] ) {
            lib->unload();
            delete lib;
        }
    }
}

bool operator<( const OPluginItem& l, const OPluginItem& r ) {
    return l.position() > r.position();
}

bool operator>( const OPluginItem& l, const OPluginItem& r ) {
    return l.position() < r.position();
}

bool operator<=( const OPluginItem& l, const OPluginItem& r ) {
    return l.position() >=  r.position();
}

OPluginItem::OPluginItem()
    : m_pos( -1 ) {
}

OPluginItem::OPluginItem( const QString& name, const QString& path, bool b, int pos )
    : m_name( name ), m_path( path ), m_enabled( b ), m_pos( pos )
{}

OPluginItem::~OPluginItem() {
}

bool OPluginItem::isEmpty()const {
    if ( m_pos != -1 )       return false;
    if ( m_enabled )         return false;
    if ( !m_name.isEmpty() ) return false;
    if ( !m_path.isEmpty() ) return false;

    return true;
}

bool OPluginItem::operator==( const OPluginItem& r )const{
    if ( m_pos     != r.m_pos    ) return false;
    if ( m_enabled != r.m_enabled) return false;
    if ( m_name    != r.m_name   ) return false;
    if ( m_path    != r.m_path   ) return false;
    return true;
}

bool OPluginItem::operator!=( const OPluginItem& r )const{
    return !( *this == r );
}

QString OPluginItem::name()const {
    return m_name;
}

QString OPluginItem::path()const {
    return m_path;
}

bool OPluginItem::isEnabled()const {
    return m_enabled;
}

int OPluginItem::position()const{
    return m_pos;
}

void OPluginItem::setName(  const QString& name ) {
    m_name = name;
}

void OPluginItem::setPath( const QString& name ) {
    m_path = name;
}

void OPluginItem::setEnabled(  bool enabled ) {
    m_enabled = enabled;
}

void OPluginItem::setPosition( int pos ) {
    m_pos = pos;
}



OGenericPluginLoader::OGenericPluginLoader( const QString& name,  bool isSorted)
    : m_dir( name ), m_autoDelete( false ), m_isSafeMode( false ),
      m_isSorted( isSorted )
{
    setPluginDir( QPEApplication::qpeDir() + "plugins/"+name );
    readConfig();
}


OGenericPluginLoader::~OGenericPluginLoader() {
    if ( m_autoDelete )
        clear();
}

void OGenericPluginLoader::setAutoDelete( bool t ) {
    m_autoDelete = t;
}

bool OGenericPluginLoader::autoDelete()const{
    return m_autoDelete;
}

void OGenericPluginLoader::clear() {
    QPtrDictIterator<QLibrary> it( m_library );
    for ( ;it.current(); )
        unload( static_cast<QUnknownInterface*>( it.currentKey() ) );
}

void OGenericPluginLoader::unload( QUnknownInterface* iface ) {
    if ( !iface )
        return;

    iface->release();
    Internal::OPluginLibraryHolder::self()->deref( m_library.take( iface ) );
}

QString OGenericPluginLoader::name()const {
    return m_dir;
}


bool OGenericPluginLoader::isInSafeMode()const {
    return m_isSafeMode;
}


OPluginItem::List OGenericPluginLoader::allAvailable( bool sorted )const {
    OPluginItem::List lst;
    for ( QStringList::ConstIterator it = m_plugDirs.begin(); it != m_plugDirs.end(); ++it )
        lst += plugins(  *it, sorted, false );

    if ( sorted )
        qHeapSort( lst );
    return lst;
}

OPluginItem::List OGenericPluginLoader::filtered( bool sorted )const {
    OPluginItem::List lst;
    for ( QStringList::ConstIterator it = m_plugDirs.begin(); it != m_plugDirs.end(); ++it )
        lst += plugins(  *it, sorted, true );

    if ( sorted )
        qHeapSort( lst );
    return lst;
}


QUnknownInterface* OGenericPluginLoader::load( const OPluginItem& item, const QUuid& uuid) {
    /*
     * Check if there could be a library
     */
    QString pa = item.path();
    if ( pa.isEmpty() )
        return 0l;

    /*
     * See if we get a library
     * return if we've none
     */
    setSafeMode( pa, true );
    QLibrary *lib = Internal::OPluginLibraryHolder::self()->ref( pa );
    if ( !lib ) {
        setSafeMode();
        return 0l;
    }

    QUnknownInterface*  iface=0;
    if ( lib->queryInterface(  uuid,  &iface ) == QS_OK ) {
        installTranslators( item.name() );
        m_library.insert( iface, lib );
    }else
        iface = 0;

    setSafeMode();

    return iface;
}

void OGenericPluginLoader::readConfig() {


/* read the config for SafeMode */
    OConfig conf(  m_dir + "-odpplugins" );
    conf.setGroup( "General" );
    m_isSafeMode = conf.readBoolEntry( "SafeMode", false );
}

void OGenericPluginLoader::setSafeMode(const QString& str, bool b) {
    OConfig conf(  m_dir + "-odpplugins" );
    conf.setGroup( "General" );
    conf.writeEntry( "SafeMode", b );
    conf.writeEntry( "CrashedPlugin", str );
}

void OGenericPluginLoader::setPluginDirs( const QStringList& lst ) {
    m_plugDirs = lst;
}

void OGenericPluginLoader::setPluginDir( const QString& str) {
    m_plugDirs.clear();
    m_plugDirs.append( str );
}


bool OGenericPluginLoader::isSorted()const{
    return m_isSorted;
}

/*
 * make libfoo.so.1.0.0 -> foo on UNIX
 * make libfoo.dylib    -> foo on MAC OS X Unix
 * windows is obviously missing
 */
QString OGenericPluginLoader::unlibify( const QString& str ) {
    QString st = str.mid( str.find( "lib" )+3 );
#ifdef Q_OS_MACX
    return st.left( st.findRev( ".dylib" ) );
#else
    return st.left( st.findRev( ".so" ) );
#endif
}

OPluginItem::List OGenericPluginLoader::plugins( const QString& _dir, bool sorted, bool disabled )const {
#ifdef Q_OS_MACX
    QDir dir( _dir, "lib*.dylib" );
#else
    QDir dir( _dir, "lib*.so" );
#endif


    OPluginItem::List lst;

    /*
     * get excluded list and then iterate over them
     * Excluded list contains the name
     * Position is a list with 'name.pos.name.pos.name.pos'
     *
     * For the look up we will create two QMap<QString,pos>
     */
    QMap<QString, int> positionMap;
    QMap<QString, int> excludedMap;


    OConfig cfg( m_dir+"-odpplugins" );
    cfg.setGroup( _dir );


    QStringList excludes = cfg.readListEntry( "Excluded", ',' );
    for ( QStringList::Iterator it = excludes.begin(); it != excludes.end(); ++it )
        excludedMap.insert( *it, -2 );

    if ( sorted ) {
        QStringList pos =  cfg.readListEntry( "Positions", '.' );
        QStringList::Iterator it = pos.begin();
        QString tmp; int i;
        while ( it != pos.end() ) {
            tmp = *it++; i = (*it++).toInt();
            positionMap.insert(  tmp, i );
        }

    }




    QStringList list = dir.entryList();
    for (QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
        QString str = unlibify( *it );
        OPluginItem item( str, _dir + "/" + *it );

        bool ex = excludedMap.contains( str );
        /*
         * if disabled but we should show all mark it as disabled
         * else continue because we don't want to add the item
         * else if sorted we assign the right position
         */
        if ( ex && !disabled)
            item.setEnabled( false );
        else if ( ex && disabled )
            continue;
        else if ( sorted )
            item.setPosition( positionMap[str] );


        lst.append( item );
    }

    return lst;
}

QStringList OGenericPluginLoader::languageList() {
    if ( m_languages.isEmpty() ) {
        /*
         * be_BY.CP1251 We will add, be_BY.CP1251,be_BY,be
         * to our list of languages.
         * Also for de_DE@euro we will add de_DE@eurp, de_DE, de
         * to our list of languages
         */
        QString str = ::getenv( "LANG" );
        m_languages += str;
        int pos = str.find( '@' );
        if( pos > 0 )
            m_languages += str.left( pos );
        
        
        pos = str.find( '.' );
        if ( pos > 0 )
            m_languages += str.left( pos );

        int n_pos = str.find( '_' );
        if ( n_pos > 0  )
            m_languages += str.left( n_pos );

    }
    return m_languages;
}

void OGenericPluginLoader::installTranslators(const QString& type) {
    QStringList lst = languageList();

    /*
     * for each language and maybe later for each language dir...
     * try to load a Translator
     */
    for ( QStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) {
        QTranslator* trans = new QTranslator(  qApp );
        QString tfn = QPEApplication::qpeDir()+"i18n/" + *it + "/lib" + type + ".qm" ;

        /*
         * If loaded then install else clean up and don't leak
         */
        if ( trans->load( tfn ) ) 
            qApp->installTranslator( trans );   
        else
            delete trans;
    }
}

OPluginLoader::OPluginLoader( const QString& name,  bool sorted )
    : OGenericPluginLoader( name, sorted )
{
}

OPluginLoader::~OPluginLoader() {
}

OPluginManager::OPluginManager(  OGenericPluginLoader* loader)
    : m_loader( loader ), m_isSorted( false )
{
}

OPluginManager::OPluginManager( const QString& name, const OPluginItem::List& lst,  bool isSorted)
    : m_loader( 0l ), m_cfgName( name ), m_plugins( lst ), m_isSorted( isSorted )
{
}

OPluginManager::~OPluginManager() {
}

OPluginItem OPluginManager::crashedPlugin()const {
    return m_crashed;
}

OPluginItem::List OPluginManager::managedPlugins()const {
    return m_plugins;
}

void OPluginManager::setPosition( const OPluginItem& item) {
    replace( item );
}

void OPluginManager::enable(  const OPluginItem& item ) {
    setEnabled( item, true );
}

void OPluginManager::disable( const OPluginItem& item) {
    setEnabled( item, false );
}

void OPluginManager::setEnabled( const OPluginItem& _item, bool b ) {
    OPluginItem item = _item;
    item.setEnabled( b );
    replace( item );
}

void OPluginManager::load() {
    OConfig cfg( configName() );
    cfg.setGroup(  "General" );
    QString crashedPath = cfg.readEntry( "CrashedPlugin" );

    /* if we've a loader this applies if we were called from the first part */
    if ( m_loader )
        m_plugins = m_loader->allAvailable( m_loader->isSorted() );

    /*  fast and normal route if we did not crash... */
    if ( crashedPath.isEmpty() )
        return;

    /* lets try to find the plugin path and this way the associated item */
    for ( OPluginItem::List::Iterator it = m_plugins.begin(); it != m_plugins.end(); ++it )
        if (  (*it).path() ==  crashedPath ) {
            m_crashed = *it;
            break;
        }
}


void OPluginManager::save() {
    QMap<QString, QStringList> excluded;  // map for path to excluded name
    QMap<QString, QStringList> positions; // if positions matter contains splitted up by dirs
    bool sorted = m_loader ? m_loader->isSorted() : m_isSorted;

    /*
     * We will create some maps for the  groups to include positions a
     */
    for ( OPluginItem::List::Iterator it = m_plugins.begin(); it != m_plugins.end(); ++it ) {
        OPluginItem item = *it;
        QString path = QFileInfo(  item.path() ).dirPath(true);
        if ( sorted ) {
            positions[path].append( item.name() );
            positions[path].append( QString::number( item.position() ) );
        }

        if ( !item.isEnabled() )
            excluded[path].append( item.name() );
        if ( !excluded.contains( path ) )
            excluded[path] = QString::null;

    }

/*
 * The code below wouldn't work because we can't delete groups/keys from the config
 * ### for ODP   make Config right!
 */
//    if ( excluded.isEmpty() && positions.isEmpty() ) return;
    /*
     * Now safe for each path
     */
    OConfig cfg( configName() );

    /* safe excluded items */
    for ( QMap<QString, QStringList>::Iterator it = excluded.begin(); it != excluded.end(); ++it ) {
        OConfigGroupSaver saver( &cfg, it.key() );
        cfg.writeEntry("Excluded", it.data(), ',' );
    }

    /*  safe positions we could also see if positions.contains(path) and remove/write in the above loop
     * ### Write a Test Suite that can profile these runs...
     */
    for ( QMap<QString, QStringList>::Iterator it = positions.begin(); it != positions.end(); ++it ) {
        OConfigGroupSaver saver( &cfg, it.key() );
        cfg.writeEntry("Positions", it.data(), '.' );
    }
}

QString OPluginManager::configName()const {
    QString str = m_loader ? m_loader->name() : m_cfgName;
    return str + "-odpplugins";
}

void OPluginManager::replace( const OPluginItem& item ) {
    OPluginItem _item;

    /* for all plugins */
    for ( OPluginItem::List::Iterator it=m_plugins.begin();it != m_plugins.end(); ++it ) {
        _item = *it;
        /* if path and name are the same we will remove, readd and return */
        if ( _item.path() == item.path() &&
             _item.name() == item.name() ) {
            it = m_plugins.remove( it );
            m_plugins.append( item );
            return;
        }

    }
}

}
}

---