ProcessInvoker.h

Go to the documentation of this file.

#ifndef _PROCESS_INVOKER_H_
#define _PROCESS_INVOKER_H_

#include <qobject.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/time.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

#include <qtimer.h>
#include <qdatastream.h>
#include <qcstring.h>
#include <qpe/qcopenvelope_qws.h>
#include <qpe/global.h>
//#include "KHUtil.h"
#include "StringParser.h"

typedef void Sigfunc(int);

#define SC_CHANNEL      "QPE/ShellCommander"

/* Sigleton Object */
class ProcessInvoker : public QObject
{
        Q_OBJECT
public:
        static ProcessInvoker& getInstance()
        {
                static ProcessInvoker instance;
                return(instance);
        }

        bool run();
        bool run(const QString& args);
        void terminate();
        void terminate(pid_t pid);
        void kill();
        void kill(pid_t pid);
        void setCommand(const QString& command){
                m_arguments.clear();
                addArgument(command);
        }
        void setArguments(const QStringList& arglist){
                m_arguments = arglist;
        }
        void setArguments(const QString& arguments){
                //setArguments(KHUtil::parseArgs(arguments));
                setArguments(StringParser::split(' ', arguments));
        }
        void addArgument(const QString& argument){
                m_arguments.append(argument);
        }
        void addArguments(const QString& arguments){
                QStringList arglist;
                //arglist = KHUtil::parseArgs(arguments);
                arglist = StringParser::split(' ', arguments);
                addArguments(arglist);
        }
        void addArguments(const QStringList& arglist){
                for(QStringList::ConstIterator it=arglist.begin();
                                it!=arglist.end(); ++it){
                        addArgument(*it);
                }
        }
        //const QStringList parseArgs(const QString& arguments);
        void setRunning(int pid);
        void setNotify(bool enable=true){
                m_isNotify = enable;
        }

        bool isRunning(){
                return(m_isRunning);
        }
        void notifyFinish(int status, bool success=true);

        pid_t m_child;

        friend class Dummy; /* for compile warning */
signals:
        void start(int, QStringList);
        void finish(QString,int);
private:
        ProcessInvoker();
        ProcessInvoker(const ProcessInvoker&);
        ProcessInvoker& operator=(const ProcessInvoker&);
        ~ProcessInvoker();

        class Dummy{}; /* for compile warning */

        QTimer* m_pTimer;
        QStringList m_arguments;

        bool m_isRunning;
        bool m_isNotify;

        Sigfunc* m_defChildHandler;

        int m_stdfd[2];
        int m_errfd[2];
        int m_maxfdp1;

        bool openPipe();
        void closePipe(int fd[] = NULL, int n = 2);
        void notifyStatus(const QString& result, int code);

        void workerProc();
private slots:
        void readOutputs();
};

#endif /* _PROCESS_INVOKER_H_ */

---