yatecbase.h

#ifndef __YATECBASE_H
#define __YATECBASE_H

#ifndef __cplusplus
#error C++ is required
#endif

#include <yatephone.h>

namespace TelEngine {

class Flags32;                           // Keeps a 32bit length flag mask
class NamedInt;                          // A named integer value
class Window;                            // A generic window
class UIWidget;                          // A custom widget
class UIFactory;                         // Base factory used to build custom widgets
class Client;                            // The client
class ClientChannel;                     // A client telephony channel
class ClientDriver;                      // The client telephony driver
class ClientLogic;                       // Base class for all client logics
class DefaultLogic;                      // The client's default logic
class ClientWizard;                      // A client wizard
class ClientAccount;                     // A client account
class ClientAccountList;                 // A client account list
class ClientContact;                     // A client contact
class ClientResource;                    // A client contact's resource
class MucRoomMember;                     // A MUC room member
class MucRoom;                           // An account's MUC room contact
class DurationUpdate;                    // Class used to update UI durations
class ClientSound;                       // A sound file
class ClientFileItem;                    // Base class for file/dir items
class ClientDir;                         // A directory
class ClientFile;                        // A file


class YATE_API Flags32
{
public:
    inline Flags32()
        : m_flags(0)
        {}

    inline Flags32(u_int32_t value)
        : m_flags(value)
        {}

    inline u_int32_t flags() const
        { return m_flags; }

    inline void set(u_int32_t mask)
        { m_flags = m_flags | mask; }

    inline void reset(u_int32_t mask)
        { m_flags = m_flags & ~mask; }

    inline u_int32_t flag(u_int32_t mask) const
        { return (m_flags & mask); }

    inline void changeFlag(u_int32_t mask, bool on) {
            if (on)
                set(mask);
            else
                reset(mask);
        }

    inline bool changeFlagCheck(u_int32_t mask, bool ok) {
            if ((0 != flag(mask)) == ok)
                return false;
            changeFlag(mask,ok);
            return true;
        }

    inline void change(u_int32_t value)
        { m_flags = value; }

    inline operator u_int32_t() const
        { return m_flags; }

    inline const Flags32& operator=(int value)
        { m_flags = value; return *this; }

protected:
    u_int32_t m_flags;
};

class YATE_API NamedInt: public String
{
    YCLASS(NamedInt,String)
public:
    inline NamedInt(const char* name, int val = 0)
        : String(name), m_value(val)
        {}

    inline NamedInt(const NamedInt& other)
        : String(other), m_value(other.value())
        {}

    inline int value() const
        { return m_value; }

    inline void setValue(int val)
        { m_value = val; }

    static void addToListUniqueName(ObjList& list, NamedInt* obj);

    static void clearValue(ObjList& list, int val);

    static inline int lookup(const ObjList& list, const String& name, int defVal = 0) {
            ObjList* o = list.find(name);
            return o ? (static_cast<NamedInt*>(o->get()))->value() : defVal;
        }

    static inline const String& lookupName(const ObjList& list, int val,
        const String& defVal = String::empty()) {
            for (ObjList* o = list.skipNull(); o; o = o->skipNext()) {
                NamedInt* ni = static_cast<NamedInt*>(o->get());
                if (ni->value() == val)
                    return *ni;
            }
            return defVal;
        }

protected:
    int m_value;

private:
    NamedInt() {}
};

class YATE_API Window : public GenObject
{
    YCLASS(Window,GenObject)
    friend class Client;
    YNOCOPY(Window); // no automatic copies please
public:
    explicit Window(const char* id = 0);

    virtual ~Window();

    virtual const String& toString() const;

    /*
     * Get the window's title (may not be displayed on screen)
     * @return Title of this window
     */
    virtual void title(const String& text);

    virtual void context(const String& text);

    virtual bool setParams(const NamedList& params);

    virtual void setOver(const Window* parent) = 0;

    virtual bool hasElement(const String& name) = 0;

    virtual bool setActive(const String& name, bool active) = 0;

    virtual bool setFocus(const String& name, bool select = false) = 0;

    virtual bool setShow(const String& name, bool visible) = 0;

    virtual bool setText(const String& name, const String& text,
        bool richText = false) = 0;

    virtual bool setCheck(const String& name, bool checked) = 0;

    virtual bool setSelect(const String& name, const String& item) = 0;

    virtual bool setUrgent(const String& name, bool urgent) = 0;

    virtual bool hasOption(const String& name, const String& item) = 0;

    virtual bool addOption(const String& name, const String& item, bool atStart = false,
        const String& text = String::empty()) = 0;

    virtual bool getOptions(const String& name, NamedList* items) = 0;

    virtual bool delOption(const String& name, const String& item) = 0;

    virtual bool addLines(const String& name, const NamedList* lines, unsigned int max,
        bool atStart = false);

    virtual bool addTableRow(const String& name, const String& item,
        const NamedList* data = 0, bool atStart = false);

    virtual bool setMultipleRows(const String& name, const NamedList& data, const String& prefix = String::empty());

    virtual bool insertTableRow(const String& name, const String& item,
        const String& before, const NamedList* data = 0);

    virtual bool delTableRow(const String& name, const String& item);

    virtual bool setTableRow(const String& name, const String& item, const NamedList* data);

    virtual bool updateTableRow(const String& name, const String& item,
        const NamedList* data = 0, bool atStart = false);

    virtual bool updateTableRows(const String& name, const NamedList* data,
        bool atStart = false);

    virtual bool getTableRow(const String& name, const String& item, NamedList* data = 0);

    virtual bool clearTable(const String& name);

    virtual bool setBusy(const String& name, bool on) = 0;

    virtual bool getText(const String& name, String& text, bool richText = false) = 0;

    virtual bool getCheck(const String& name, bool& checked) = 0;

    virtual bool getSelect(const String& name, String& item) = 0;

    virtual bool getSelect(const String& name, NamedList& items) = 0;

    virtual bool buildMenu(const NamedList& params) = 0;

    virtual bool removeMenu(const NamedList& params) = 0;

    virtual bool setImage(const String& name, const String& image, bool fit = false) = 0;

    virtual bool setProperty(const String& name, const String& item, const String& value)
        { return false; }

    virtual bool getProperty(const String& name, const String& item, String& value)
        { return false; }

    inline void populate() {
            if (m_populated)
                return;
            doPopulate();
            m_populated = true;
        }

    inline void init() {
            if (m_initialized)
                return;
            doInit();
            m_initialized = true;
        }

    virtual void show() = 0;

    virtual void hide() = 0;

    virtual void size(int width, int height) = 0;

    virtual void move(int x, int y) = 0;

    virtual void moveRel(int dx, int dy) = 0;

    virtual bool related(const Window* wnd) const;

    virtual void menu(int x, int y) = 0;

    virtual bool canClose()
        { return true; }

    inline const String& id() const
        { return m_id; }

    /*
     * Get the window's title (may not be displayed on screen)
     * @return Title of this window
     */
    inline const String& title() const
        { return m_title; }

    inline const String& context() const
        { return m_context; }

    inline bool visible() const
        { return m_visible; }

    inline void visible(bool yes)
        { if (yes) show(); else hide(); }

    inline bool active() const
        { return m_active; }

    inline bool master() const
        { return m_master; }

    inline bool popup() const
        { return m_popup; }

    virtual bool createDialog(const String& name, const String& title,
        const String& alias = String::empty(), const NamedList* params = 0) = 0;

    virtual bool closeDialog(const String& name) = 0;

    static bool isValidParamPrefix(const String& prefix);

protected:
    virtual void doPopulate() = 0;
    virtual void doInit() = 0;

    String m_id;
    String m_title;
    String m_context;
    bool m_visible;
    bool m_active;
    bool m_master;
    bool m_popup;
    bool m_saveOnClose;                  // Save window's data when destroyed

private:
    bool m_populated;                    // Already populated flag
    bool m_initialized;                  // Already initialized flag
};

class YATE_API UIWidget : public String
{
    YCLASS(UIWidget,String)
    YNOCOPY(UIWidget); // no automatic copies please
public:
    inline explicit UIWidget(const char* name = 0)
        : String(name)
        { }

    virtual ~UIWidget()
        { }

    inline const String& name() const
        { return toString(); }

    virtual bool setParams(const NamedList& params)
        { return false; }

    virtual bool getOptions(NamedList& items)
        { return false; }

    virtual bool addTableRow(const String& item, const NamedList* data = 0,
        bool atStart = false)
        { return false; }

    virtual bool setMultipleRows(const NamedList& data, const String& prefix = String::empty())
        { return false; }

    virtual bool updateTableRows(const NamedList* data, bool atStart = false)
        { return false; }

    virtual bool insertTableRow(const String& item, const String& before,
        const NamedList* data = 0)
        { return false; }

    virtual bool delTableRow(const String& item)
        { return false; }

    virtual bool setTableRow(const String& item, const NamedList* data)
        { return false; }

    virtual bool getTableRow(const String& item, NamedList* data = 0)
        { return false; }

    virtual bool clearTable()
        { return false; }

    virtual bool setSelect(const String& item)
        { return false; }

    virtual bool getSelect(String& item)
        { return false; }

    virtual bool getSelect(NamedList& items)
        { return false; }

    virtual bool addLines(const NamedList& lines, unsigned int max, bool atStart = false)
        { return false; }

    virtual bool setText(const String& text, bool richText = false)
        { return false; }

    virtual bool getText(String& text, bool richText = false)
        { return false; }

    virtual bool setBusy(bool on)
        { return false; }
};

class YATE_API UIFactory : public String
{
    YCLASS(UIFactory,String)
    YNOCOPY(UIFactory); // no automatic copies please
public:
    explicit UIFactory(const char* name);

    virtual ~UIFactory();

    inline bool canBuild(const String& type)
        { return 0 != m_types.find(type); }

    virtual void* create(const String& type, const char* name, NamedList* params = 0) = 0;

    static void* build(const String& type, const char* name, NamedList* params = 0,
        const char* factory = 0);

protected:
    ObjList m_types;                     // List of object types this factory can build

private:
    static ObjList s_factories;          // Registered factories list
};

class YATE_API Client : public MessageReceiver
{
    YCLASS(Client,MessageReceiver)
    friend class Window;
    friend class ClientChannel;
    friend class ClientDriver;
    friend class ClientLogic;
public:
    enum MsgID {
        CallCdr = 0,
        UiAction,
        UserLogin,
        UserNotify,
        ResourceNotify,
        ResourceSubscribe,
        ClientChanUpdate,
        UserRoster,
        ContactInfo,
        // Handlers not automatically installed
        ChanNotify,
        MucRoom,
        // IDs used only to postpone messages
        MsgExecute,
        EngineStart,
        TransferNotify,
        UserData,
        FileInfo,
        // Starting value for custom relays
        MsgIdCount
    };

    enum ClientToggle {
        OptMultiLines = 0,               // Accept incoming calls
        OptAutoAnswer,                   // Auto answer incoming calls
        OptRingIn,                       // Enable/disable incoming ringer
        OptRingOut,                      // Enable/disable outgoing ringer
        OptActivateLastOutCall,          // Set the last outgoing call active
        OptActivateLastInCall,           // Set the last incoming call active
        OptActivateCallOnSelect,         // Set the active call when selected in channel
                                         //  list (don't require double click)
        OptKeypadVisible,                // Show/hide keypad
        OptOpenIncomingUrl,              // Open an incoming URL in call.execute message
        OptAddAccountOnStartup,          // Open account add window on startup
        OptDockedChat,                   // Show all contacts chat in the same window
        OptDestroyChat,                  // Destroy contact chat when contact is removed/destroyed
        OptNotifyChatState,              // Notify chat states
        OptShowEmptyChat,                // Display received empty chat in chat history
        OptSendEmptyChat,                // Send empty chat
        OptCount
    };

    enum TrayIconType {
        TrayIconMain = 0,
        TrayIconInfo = 1000,
        TrayIconIncomingChat = 3000,
        TrayIconNotification = 5000,
        TrayIconIncomingCall = 10000,
    };

    explicit Client(const char *name = 0);

    virtual ~Client();

    virtual bool startup();

    virtual void run();

    virtual void cleanup();

    virtual void main() = 0;

    virtual void lock() = 0;

    virtual void unlock() = 0;

    inline void lockOther()
        { if (!m_oneThread) lock(); }

    inline void unlockOther()
        { if (!m_oneThread) unlock(); }

    inline void setThread(Thread* th)
        { m_clientThread = th; }

    virtual void allHidden() = 0;

    void loadUI(const char* file = 0, bool init = true);

    virtual void quit() = 0;

    bool openUrlSafe(const String& url);

    virtual bool openUrl(const String& url) = 0;

    virtual bool received(Message& msg, int id);

    virtual bool createWindowSafe(const String& name,
        const String& alias = String::empty());

    virtual bool createDialog(const String& name, Window* parent, const String& title,
        const String& alias = String::empty(), const NamedList* params = 0);

    virtual bool createObject(void** dest, const String& type, const char* name,
        NamedList* params = 0);

    virtual bool closeWindow(const String& name, bool hide = true);

    virtual bool closeDialog(const String& name, Window* wnd, Window* skip = 0);

    virtual bool debugHook(bool active);

    virtual bool addToLog(const String& text);

    virtual bool setStatus(const String& text, Window* wnd = 0);

    bool setStatusLocked(const String& text, Window* wnd = 0);

    bool setParams(const NamedList* params, Window* wnd = 0, Window* skip = 0);

    virtual bool action(Window* wnd, const String& name, NamedList* params = 0);

    virtual bool toggle(Window* wnd, const String& name, bool active);

    virtual bool select(Window* wnd, const String& name, const String& item, const String& text = String::empty());

    virtual bool select(Window* wnd, const String& name, const NamedList& items);

    inline bool oneThread() const
        { return m_oneThread; }

    inline int line() const
        { return m_line; }

    void line(int newLine);

    bool hasElement(const String& name, Window* wnd = 0, Window* skip = 0);
    bool setActive(const String& name, bool active, Window* wnd = 0, Window* skip = 0);
    bool setFocus(const String& name, bool select = false, Window* wnd = 0, Window* skip = 0);
    bool setShow(const String& name, bool visible, Window* wnd = 0, Window* skip = 0);
    bool setText(const String& name, const String& text, bool richText = false,
        Window* wnd = 0, Window* skip = 0);
    bool setCheck(const String& name, bool checked, Window* wnd = 0, Window* skip = 0);
    bool setSelect(const String& name, const String& item, Window* wnd = 0, Window* skip = 0);
    bool setUrgent(const String& name, bool urgent, Window* wnd = 0, Window* skip = 0);
    bool hasOption(const String& name, const String& item, Window* wnd = 0, Window* skip = 0);

    virtual bool getOptions(const String& name, NamedList* items,
        Window* wnd = 0, Window* skip = 0);

    bool addOption(const String& name, const String& item, bool atStart,
        const String& text = String::empty(), Window* wnd = 0, Window* skip = 0);
    bool delOption(const String& name, const String& item, Window* wnd = 0, Window* skip = 0);

    bool addLines(const String& name, const NamedList* lines, unsigned int max,
        bool atStart = false, Window* wnd = 0, Window* skip = 0);

    bool addTableRow(const String& name, const String& item, const NamedList* data = 0,
        bool atStart = false, Window* wnd = 0, Window* skip = 0);

    bool setMultipleRows(const String& name, const NamedList& data, const String& prefix = String::empty(), Window* wnd = 0, Window* skip = 0);

    bool insertTableRow(const String& name, const String& item,
        const String& before, const NamedList* data = 0,
        Window* wnd = 0, Window* skip = 0);

    bool delTableRow(const String& name, const String& item, Window* wnd = 0, Window* skip = 0);
    bool setTableRow(const String& name, const String& item, const NamedList* data,
        Window* wnd = 0, Window* skip = 0);
    bool getTableRow(const String& name, const String& item, NamedList* data = 0,
        Window* wnd = 0, Window* skip = 0);
    bool clearTable(const String& name, Window* wnd = 0, Window* skip = 0);

    bool updateTableRow(const String& name, const String& item, const NamedList* data = 0,
        bool atStart = false, Window* wnd = 0, Window* skip = 0);

    bool updateTableRows(const String& name, const NamedList* data, bool atStart = false,
        Window* wnd = 0, Window* skip = 0);

    bool setBusy(const String& name, bool on, Window* wnd = 0, Window* skip = 0);

    bool getText(const String& name, String& text, bool richText = false, Window* wnd = 0, Window* skip = 0);

    bool getCheck(const String& name, bool& checked, Window* wnd = 0, Window* skip = 0);
    bool getSelect(const String& name, String& item, Window* wnd = 0, Window* skip = 0);

    bool getSelect(const String& name, NamedList& items, Window* wnd = 0, Window* skip = 0);

    bool buildMenu(const NamedList& params, Window* wnd = 0, Window* skip = 0);

    bool removeMenu(const NamedList& params, Window* wnd = 0, Window* skip = 0);

    virtual bool setImage(const String& name, const String& image,
        Window* wnd = 0, Window* skip = 0);

    virtual bool setImageFit(const String& name, const String& image,
        Window* wnd = 0, Window* skip = 0);

    virtual bool setProperty(const String& name, const String& item, const String& value,
        Window* wnd = 0, Window* skip = 0);

    virtual bool getProperty(const String& name, const String& item, String& value,
        Window* wnd = 0, Window* skip = 0);

    void moveRelated(const Window* wnd, int dx, int dy);
    inline bool initialized() const
        { return m_initialized; }
    inline static Client* self()
        { return s_client; }
    inline static void setSelf(Client* client)
        { s_client = client; }

    static inline bool valid()
        { return self() && (self()->isUIThread() || !(exiting() || Engine::exiting())); }

    static bool isClientMsg(Message& msg);

    inline static bool changing()
        { return (s_changing > 0); }
    static Window* getWindow(const String& name);
    static bool setVisible(const String& name, bool show = true, bool activate = false);
    static bool getVisible(const String& name);
    static bool openPopup(const String& name, const NamedList* params = 0, const Window* parent = 0);
    static bool openMessage(const char* text, const Window* parent = 0, const char* context = 0);
    static bool openConfirm(const char* text, const Window* parent = 0, const char* context = 0);
    static ObjList* listWindows();
    void idleActions();

    bool postpone(const Message& msg, int id, bool copyUserData = false);

    virtual bool chooseFile(Window* parent, NamedList& params)
        { return false; }

    virtual bool setClientParam(const String& param, const String& value,
        bool save, bool update);

    virtual bool backspace(const String& name, Window* wnd = 0);

    void installRelay(const char* name, int id, int prio);

    virtual bool callRouting(Message& msg)
        { return true;}

    virtual bool imRouting(Message& msg)
        { return true;}

    virtual bool imExecute(Message& msg);

    virtual bool buildIncomingChannel(Message& msg, const String& dest);

    virtual bool buildOutgoingChannel(NamedList& params);

    bool callIncoming(Message& msg, const String& dest);

    void callAnswer(const String& id, bool setActive = true);

    void callTerminate(const String& id, const char* reason = 0, const char* error = 0);

    ClientChannel* getActiveChannel();

    virtual bool ringer(bool in, bool on);

    virtual bool createSound(const char* name, const char* file, const char* device = 0)
        { return false; }

    bool emitDigits(const char* digits, const String& id = String::empty());

    inline bool emitDigit(char digit, const String& id = String::empty()) {
            char s[2] = {digit,0};
            return emitDigits(s,id);
        }

    inline bool getBoolOpt(ClientToggle toggle)
        { return toggle < OptCount ? m_toggles[toggle] : false; }

    bool setBoolOpt(ClientToggle toggle, bool value, bool updateUi = false);

    virtual bool formatDateTime(String& dest, unsigned int secs, const char* format,
        bool utc = false)
        { return false; }

    static inline bool exiting()
        { return s_exiting; }

    static bool getActive(const String& name);

    static Message* buildMessage(const char* msg, const String& account,
        const char* oper = 0);

    static Message* buildNotify(bool online, const String& account,
        const ClientResource* from = 0);

    static Message* buildSubscribe(bool request, bool ok, const String& account,
        const String& contact, const char* proto = 0);

    static Message* buildUserRoster(bool update, const String& account,
        const String& contact, const char* proto = 0);

    static bool addLogic(ClientLogic* logic);

    static void removeLogic(ClientLogic* logic);

    static ClientLogic* findLogic(const String& name);

    static Message* eventMessage(const String& event, Window* wnd = 0,
        const char* name = 0, NamedList* params = 0);

    static bool save(Configuration& cfg, Window* parent = 0, bool showErr = true);

    static ClientToggle getBoolOpt(const String& name);

    static inline void setLogicsTick()
        { s_idleLogicsTick = true; }

    static void appendEscape(String& buf, ObjList& list, char sep = ',', bool force = false);

    static ObjList* splitUnescape(const String& buf, char sep = ',', bool emptyOk = false);

    static void removeChars(String& buf, const char* chars);

    static void fixPhoneNumber(String& number, const char* chars = 0);

    static bool addTrayIcon(const String& wndName, int prio, NamedList* params);

    static bool removeTrayIcon(const String& wndName, const String& name);

    static bool updateTrayIcon(const String& wndName);

    static void generateGuid(String& buf, const String& extra = String::empty());

    static void plain2html(String& buf, bool spaceEol = false);

    static NamedString* findParamByValue(NamedList& list, const String& value,
        NamedString* skip = 0);

    static int decodeFlags(const TokenDict* dict, const NamedList& params,
        const String& prefix = String::empty());

    static int decodeFlags(const TokenDict* dict, const String& flags, int defVal = 0);

    static void addPathSep(String& dest, const String& path, char sep = 0);

    static void fixPathSep(String& path);

    static bool removeEndsWithPathSep(String& dest, const String& path, char sep = 0);

    static bool getLastNameInPath(String& dest, const String& path, char sep = 0);

    static bool removeLastNameInPath(String& dest, const String& path, char sep = 0,
        const String& equalOnly = String::empty());

    static bool addToLogFormatted(const char* format, ...);

    static Configuration s_settings;     // Client settings
    static Configuration s_actions;      // Logic preferrences
    static Configuration s_accounts;     // Accounts
    static Configuration s_contacts;     // Contacts
    static Configuration s_providers;    // Provider settings
    static Configuration s_history;      // Call log
    static Configuration s_calltoHistory;  // Dialed destinations history
    // Holds a not selected/set value match
    static Regexp s_notSelected;
    // Regexp used to check if a string is a GUID in the format
    // 8*HEX-4*HEX-4*HEX-4*HEX-12*HEX
    static Regexp s_guidRegexp;
    // Paths
    static String s_skinPath;
    static String s_soundPath;
    // Ring name for incoming channels
    static String s_ringInName;
    // Ring name for outgoing channels
    static String s_ringOutName;
    // Status widget's name
    static String s_statusWidget;
    // Widget displaying the debug text
    static String s_debugWidget;
    // The list of cient's toggles
    static String s_toggles[OptCount];
    // Maximum remote users allowed to enter in conference
    static int s_maxConfPeers;
    // Engine started flag
    static bool s_engineStarted;

protected:
    virtual ClientLogic* createDefaultLogic();
    virtual bool createWindow(const String& name,
        const String& alias = String::empty()) = 0;
    virtual void loadWindows(const char* file = 0) = 0;
    virtual void initWindows();
    virtual void initClient();
    virtual void exitClient()
        {}
    virtual bool isUIThread()
        { return Thread::current() == m_clientThread; }
    inline bool needProxy() const
        { return m_oneThread && !(Client::self() && Client::self()->isUIThread()); }
    bool driverLockLoop();
    static bool driverLock(long maxwait = 0);
    static void driverUnlock();

    static bool s_exiting;               // Exiting flag

    ObjList m_windows;
    bool m_initialized;
    int m_line;
    bool m_oneThread;
    bool m_toggles[OptCount];
    ObjList m_relays;                    // Message relays installed by this receiver
    ClientLogic* m_defaultLogic;         // The default logic
    static Client* s_client;
    static int s_changing;
    static ObjList s_logics;
    static bool s_idleLogicsTick;        // Call logics' timerTick()
    Thread* m_clientThread;
};

class YATE_API ClientChannel : public Channel
{
    YCLASS(ClientChannel,Channel)
    friend class ClientDriver;
    YNOCOPY(ClientChannel); // no automatic copies please
public:
    enum Notification {
        Startup,
        Destroyed,
        Active,
        OnHold,
        Mute,
        Noticed,
        AddrChanged,
        Routed,
        Accepted,
        Rejected,
        Progressing,
        Ringing,
        Answered,
        Transfer,
        Conference,
        AudioSet,
        Unknown
    };

    enum SlaveType {
        SlaveNone = 0,
        SlaveTransfer,
        SlaveConference,
    };

    ClientChannel(const Message& msg, const String& peerid);

    ClientChannel(const String& target, const NamedList& params, int st = SlaveNone,
        const String& masterChan = String::empty());

    explicit ClientChannel(const String& soundId);

    virtual ~ClientChannel();

    bool start(const String& target, const NamedList& params);

    virtual bool msgProgress(Message& msg);
    virtual bool msgRinging(Message& msg);
    virtual bool msgAnswered(Message& msg);
    virtual bool msgDrop(Message& msg, const char* reason);
    virtual bool callRouted(Message& msg);
    virtual void callAccept(Message& msg);
    virtual void callRejected(const char* error, const char* reason, const Message* msg);

    void callAnswer(bool setActive = true);

    inline int slave() const
        { return m_slave; }

    inline ObjList& slaves()
        { return m_slaves; }

    inline unsigned int slavesCount() const {
            Lock lock(m_mutex);
            return m_slaves.count();
        }

    inline void addSlave(const String& sid) {
            Lock lock(m_mutex);
            if (!m_slaves.find(sid))
                m_slaves.append(new String(sid));
        }

    inline void removeSlave(const String& sid) {
            Lock lock(m_mutex);
            m_slaves.remove(sid);
        }

    inline const String& master() const
        { return m_master; }

    inline const NamedList& clientParams() const
        { return m_clientParams; }

    inline const String& party() const
        { return m_party; }

    inline const String& partyName() const
        { return m_partyName ? m_partyName : m_party; }

    inline bool conference() const
        { return m_conference; }

    inline const String& transferId() const
        { return m_transferId; }

    inline RefObject* clientData() const
        { return m_clientData; }

    inline void setClientData(RefObject* obj = 0) {
            TelEngine::destruct(m_clientData);
            if (obj && obj->ref())
                m_clientData = obj;
        }

    bool setMedia(bool open = false, bool replace = false);

    bool setActive(bool active, bool update = true);

    bool setMuted(bool on, bool update = true);

    void setTransfer(const String& target = String::empty());

    void setConference(const String& target = String::empty());

    inline const String& peerOutFormat() const
        { return m_peerOutFormat; }

    inline const String& peerInFormat() const
        { return m_peerInFormat; }

    inline bool active() const
        { return m_active; }

    inline bool muted() const
        { return m_muted; }

    inline bool isNoticed() const
        { return m_noticed; }

    void noticed();

    inline int line() const
        { return m_line; }

    void line(int newLine);

    void update(int notif, bool chan = true,
        bool updatePeer = true, const char* engineMsg = 0,
        bool minimal = false, bool data = false);

    inline void getReconnPeer(String& buf) {
            Lock lck(m_mutex);
            buf = m_peerId;
        }
    inline bool hasReconnPeer()
        { return 0 != getReconnPeer(false); }

    CallEndpoint* getReconnPeer(bool ref = true);

    void dropReconnPeer(const char* reason = 0);

    static int lookup(const char* notif, int def = Unknown)
        { return TelEngine::lookup(notif,s_notification,def); }

    static const char* lookup(int notif, const char* def = 0)
        { return TelEngine::lookup(notif,s_notification,def); }

    static int lookupSlaveType(const char* notif, int def = SlaveNone)
        { return TelEngine::lookup(notif,s_slaveTypes,def); }

    static const TokenDict s_notification[];

    static const TokenDict s_slaveTypes[];

protected:
    virtual void destroyed();
    virtual void connected(const char* reason);
    virtual void disconnected(bool final, const char* reason);
    // Check for a source in channel's peer or a received message's user data
    inline bool peerHasSource(Message& msg) {
            CallEndpoint* ch = getPeer();
            if (!ch)
                ch = static_cast<CallEndpoint*>(msg.userObject(YATOM("CallEndpoint")));
            return ch && ch->getSource();
        }
    // Check if our consumer's source sent any data
    // Don't set the silence flag is already reset
    void checkSilence();

    int m_slave;                         // Slave type
    String m_master;                     // Master channel id
    String m_party;                      // Remote party
    String m_partyName;                  // Remote party name
    String m_peerOutFormat;              // Peer consumer's data format
    String m_peerInFormat;               // Peer source's data format
    String m_reason;                     // Termination reason
    String m_peerId;                     // Peer's id (used to re-connect)
    bool m_noticed;                      // Incoming channel noticed flag
    int m_line;                          // Channel's line (address)
    bool m_active;                       // Channel active flag
    bool m_silence;                      // True if the peer did't sent us any audio data
    bool m_conference;                   // True if this channel is in conference
    bool m_muted;                        // True if this channel is muted (no data source))
    String m_transferId;                 // Transferred id or empty if not transferred
    RefObject* m_clientData;             // Obscure data used by client logics
    bool m_utility;                      // Regular client channel flag
    String m_soundId;                    // The id of the sound to play
    ObjList m_slaves;                    // Data managed by the default logic
    NamedList m_clientParams;            // Channel client parameters
};

class YATE_API ClientDriver : public Driver
{
    YCLASS(ClientDriver,Driver)
    friend class ClientChannel;          // Reset active channel's id
    YNOCOPY(ClientDriver);               // No automatic copies please
public:
    ClientDriver();
    virtual ~ClientDriver();
    virtual void initialize() = 0;
    virtual bool msgExecute(Message& msg, String& dest);
    virtual void msgTimer(Message& msg);
    virtual bool msgRoute(Message& msg);
    virtual bool received(Message& msg, int id);

    inline const String& activeId() const
        { return m_activeId; }

    bool setActive(const String& id = String::empty());

    ClientChannel* findLine(int line);

    inline static ClientDriver* self()
        { return s_driver; }

    inline static const String& device()
        { return s_device; }

    static void dropCalls(const char* reason = 0);

    static bool setAudioTransfer(const String& id, const String& target = String::empty());

    static bool setConference(const String& id, bool in, const String* confName = 0,
        bool buildFromChan = false);

    static ClientChannel* findChan(const String& id);

    static ClientChannel* findChanByPeer(const String& peer);

    static inline ClientChannel* findActiveChan()
        { return self() ? findChan(self()->activeId()) : 0; }

    static void dropChan(const String& chan, const char* reason = 0, bool peer = false);

    static String s_confName;

    static bool s_dropConfPeer;

protected:
    void setup();
    static ClientDriver* s_driver;
    static String s_device;
    String m_activeId;                   // The active channel's id
};

class YATE_API ClientLogic : public GenObject
{
    YCLASS(ClientLogic,GenObject)
    friend class Client;
    YNOCOPY(ClientLogic); // no automatic copies please
public:
    virtual ~ClientLogic();

    inline const String& name() const
        { return m_name; }

    inline int priority() const
        { return m_prio; }

    virtual const String& toString() const;

    bool setParams(const NamedList& params);

    virtual bool action(Window* wnd, const String& name, NamedList* params = 0)
        { return false; }

    virtual bool toggle(Window* wnd, const String& name, bool active)
        { return false; }

    virtual bool select(Window* wnd, const String& name, const String& item,
        const String& text = String::empty())
        { return false; }

    virtual bool select(Window* wnd, const String& name, const NamedList& items)
        { return false; }

    virtual bool setClientParam(const String& param, const String& value,
        bool save, bool update)
        { return false; }

    virtual bool imIncoming(Message& msg)
        { return false; }

    virtual bool callIncoming(Message& msg, const String& dest)
        { return false; }

    virtual bool validateCall(NamedList& params, Window* wnd = 0)
        { return true; }

    virtual bool callStart(NamedList& params, Window* wnd = 0,
        const String& cmd = String::empty())
        { return false; }

    virtual bool line(const String& name, Window* wnd = 0);

    virtual bool display(NamedList& params, bool widget, Window* wnd = 0);

    virtual bool backspace(const String& name, Window* wnd = 0);

    virtual bool command(const String& name, Window* wnd = 0);

    virtual bool debug(const String& name, bool active, Window* wnd = 0);

    virtual bool editAccount(bool newAcc, NamedList* params, Window* wnd = 0)
        { return false; }

    virtual bool acceptAccount(NamedList* params, Window* wnd = 0)
        { return false; }

    virtual bool delAccount(const String& account, Window* wnd = 0)
        { return false; }

    virtual bool updateAccount(const NamedList& account, bool login, bool save)
        { return false; }

    virtual bool loginAccount(const NamedList& account, bool login)
        { return false; }

    virtual bool updateContact(const NamedList& contact, bool save, bool update)
        { return false; }

    virtual bool acceptContact(NamedList* params, Window* wnd = 0)
        { return false; }

    virtual bool editContact(bool newCont, NamedList* params = 0, Window* wnd = 0)
        { return false; }

    virtual bool delContact(const String& contact, Window* wnd = 0)
        { return false; }

    virtual bool callContact(NamedList* params = 0, Window* wnd = 0)
        { return false; }

    virtual bool updateProviders(const NamedList& provider, bool save, bool update)
        { return false; }

    virtual bool callLogUpdate(const NamedList& params, bool save, bool update)
        { return false; }

    virtual bool callLogDelete(const String& billid)
        { return false; }

    virtual bool callLogClear(const String& table, const String& direction)
        { return false; }

    virtual bool callLogCall(const String& billid, Window* wnd = 0)
        { return false; }

    virtual bool callLogCreateContact(const String& billid)
        { return false; }

    virtual bool help(const String& action, Window* wnd)
        { return false; }

    virtual bool calltoLoaded()
        { return false; }

    virtual void loadedWindows()
        {}

    virtual void initializedWindows()
        {}

    virtual bool initializedClient()
        { return false; }

    virtual void exitingClient()
        {}

    virtual bool handleUiAction(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleCallCdr(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleUserLogin(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleUserNotify(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleUserRoster(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleResourceNotify(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleResourceSubscribe(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleClientChanUpdate(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool handleContactInfo(Message& msg, bool& stopLogic)
        { return false; }

    virtual bool defaultMsgHandler(Message& msg, int id, bool& stopLogic)
        { return false; }

    virtual void engineStart(Message& msg)
        {}

    virtual bool addDurationUpdate(DurationUpdate* duration, bool autoDelete = false);

    virtual bool removeDurationUpdate(const String& name, bool delObj = false);

    virtual bool removeDurationUpdate(DurationUpdate* duration, bool delObj = false);

    virtual DurationUpdate* findDurationUpdate(const String& name, bool ref = true);

    virtual void clearDurationUpdate();

    virtual void destruct();

    static const String& cdrRemoteParty(const NamedList& params, bool outgoing)
        { return outgoing ? params[YSTRING("called")] : params[YSTRING("caller")]; }

    static const String& cdrRemoteParty(const NamedList& params) {
            const String& dir = params[YSTRING("direction")];
            if (dir == YSTRING("incoming"))
                return cdrRemoteParty(params,true);
            if (dir == YSTRING("outgoing"))
                return cdrRemoteParty(params,false);
            return String::empty();
        }

    static void initStaticData();

    static bool saveContact(Configuration& cfg, ClientContact* c, bool save = true);

    static bool clearContact(Configuration& cfg, ClientContact* c, bool save = true);

    // Account options string list
    static ObjList s_accOptions;
    // Parameters that are applied from provider template
    static const char* s_provParams[];
    // The list of protocols supported by the client
    static ObjList s_protocols;
    // Mutext used to lock protocol list
    static Mutex s_protocolsMutex;

protected:
    ClientLogic(const char* name, int priority);

    virtual void idleTimerTick(Time& time)
        {}

    ObjList m_durationUpdate;            // Duration updates
    Mutex m_durationMutex;               // Lock duration operations

private:
    ClientLogic() {}                     // No default constructor

    String m_name;                       // Logic's name
    int m_prio;                          // Logics priority
};

class FtManager;

class YATE_API DefaultLogic : public ClientLogic
{
    YCLASS(DefaultLogic,ClientLogic)
    YNOCOPY(DefaultLogic); // no automatic copies please
public:
    explicit DefaultLogic(const char* name = "default", int prio = -100);

    ~DefaultLogic();

    virtual bool action(Window* wnd, const String& name, NamedList* params = 0);

    virtual bool toggle(Window* wnd, const String& name, bool active);

    virtual bool select(Window* wnd, const String& name, const String& item,
        const String& text = String::empty());

    virtual bool select(Window* wnd, const String& name, const NamedList& items);

    virtual bool setClientParam(const String& param, const String& value,
        bool save, bool update);

    virtual bool imIncoming(Message& msg);

    virtual bool callIncoming(Message& msg, const String& dest);

    virtual bool validateCall(NamedList& params, Window* wnd = 0);

    virtual bool callStart(NamedList& params, Window* wnd = 0,
        const String& cmd = String::empty());

    virtual bool digitPressed(NamedList& params, Window* wnd = 0);

    virtual bool editAccount(bool newAcc, NamedList* params, Window* wnd = 0);

    virtual bool acceptAccount(NamedList* params, Window* wnd = 0);

    virtual bool delAccount(const String& account, Window* wnd = 0);

    virtual bool updateAccount(const NamedList& account, bool login, bool save);

    virtual bool loginAccount(const NamedList& account, bool login);

    virtual bool updateContact(const NamedList& contact, bool save, bool update);

    virtual bool acceptContact(NamedList* params, Window* wnd = 0);

    virtual bool editContact(bool newCont, NamedList* params = 0, Window* wnd = 0);

    virtual bool delContact(const String& contact, Window* wnd = 0);

    virtual bool callContact(NamedList* params = 0, Window* wnd = 0);

    virtual bool updateProviders(const NamedList& provider, bool save, bool update);

    virtual bool callLogUpdate(const NamedList& params, bool save, bool update);

    virtual bool callLogDelete(const String& billid);

    virtual bool callLogClear(const String& table, const String& direction);

    virtual bool callLogCall(const String& billid, Window* wnd = 0);

    virtual bool callLogCreateContact(const String& billid);

    virtual bool help(const String& action, Window* wnd);

    virtual bool calltoLoaded();

    virtual void loadedWindows()
        {}

    virtual void initializedWindows();

    virtual bool initializedClient();

    virtual void exitingClient();

    virtual bool handleUiAction(Message& msg, bool& stopLogic);

    virtual bool handleCallCdr(Message& msg, bool& stopLogic);

    virtual bool handleUserLogin(Message& msg, bool& stopLogic);

    virtual bool handleUserNotify(Message& msg, bool& stopLogic);

    virtual bool handleUserRoster(Message& msg, bool& stopLogic);

    virtual bool handleResourceNotify(Message& msg, bool& stopLogic);

    virtual bool handleResourceSubscribe(Message& msg, bool& stopLogic);

    virtual bool handleClientChanUpdate(Message& msg, bool& stopLogic);

    virtual bool handleContactInfo(Message& msg, bool& stopLogic);

    virtual bool defaultMsgHandler(Message& msg, int id, bool& stopLogic);

    virtual void updateSelectedChannel(const String* item = 0);

    virtual void engineStart(Message& msg);

    virtual void showInCallNotification(ClientChannel* chan);

    virtual void closeInCallNotification(const String& id);

    static inline String& buildAccountId(String& accId, const String& proto,
        const String& user, const String& host) {
            accId = proto + ":" + user + "@" + host;
            return accId;
        }

protected:
    virtual void idleTimerTick(Time& time);

    virtual bool enableCallActions(const String& id);

    virtual bool fillCallStart(NamedList& p, Window* wnd = 0);

    virtual void channelSelectionChanged(const String& old);

    virtual void fillContactEditActive(NamedList& list, bool active, const String* item = 0,
        bool del = true);

    virtual void fillLogContactActive(NamedList& list, bool active, const String* item = 0);

    virtual bool clearList(const String& action, Window* wnd);

    virtual bool deleteItem(const String& list, const String& item, Window* wnd,
        bool confirm);

    virtual bool deleteCheckedItems(const String& list, Window* wnd, bool confirm);

    virtual bool deleteSelectedItem(const String& action, Window* wnd, bool checked = false);

    virtual bool handleTextChanged(NamedList* params, Window* wnd);

    virtual bool handleFileTransferAction(const String& name, Window* wnd, NamedList* params = 0);

    virtual bool handleFileTransferNotify(Message& msg, bool& stopLogic);

    virtual bool handleUserData(Message& msg, bool& stopLogic);

    virtual bool handleFileInfo(Message& msg, bool& stopLogic);

    virtual void notifyGenericError(const String& text,
        const String& account = String::empty(),
        const String& contact = String::empty(),
        const char* title = "Error");

    virtual void notifyNoAudio(bool show, bool micOk = false, bool speakerOk = false,
        ClientChannel* chan = 0);

    virtual void updateChatRoomsContactList(bool load, ClientAccount* acc,
        MucRoom* room = 0);

    virtual void joinRoom(MucRoom* room, bool force = false);

    String m_selectedChannel;            // The currently selected channel
    String m_transferInitiated;          // Tranfer initiated id

private:
    // Add/set an account changed in UI
    // replace: Optional editing account to replace
    bool updateAccount(const NamedList& account, bool save,
        const String& replace = String::empty(), bool loaded = false);
    // Add/edit an account
    bool internalEditAccount(bool newAcc, const String* account, NamedList* params, Window* wnd);
    // Handle dialog actions. Return true if handled
    bool handleDialogAction(const String& name, bool& retVal, Window* wnd);
    // Handle chat and contact related actions. Return true if handled
    bool handleChatContactAction(const String& name, Window* wnd);
    // Handle chat contact edit ok button press. Return true if handled
    bool handleChatContactEditOk(const String& name, Window* wnd);
    // Handle chat room contact edit ok button press. Return true if handled
    bool handleChatRoomEditOk(const String& name, Window* wnd);
    // Handle actions from MUCS window. Return true if handled
    bool handleMucsAction(const String& name, Window* wnd, NamedList* params);
    // Handle ok button in muc invite window. Return true if handled
    bool handleMucInviteOk(Window* wnd);
    // Handle select from MUCS window. Return true if handled
    bool handleMucsSelect(const String& name, const String& item, Window* wnd,
        const String& text = String::empty());
    // Handle resource.notify messages from MUC rooms
    // The account was already checked
    bool handleMucResNotify(Message& msg, ClientAccount* acc, const String& contact,
        const String& instance, const String& operation);
    // Show/hide the notification area (messages).
    // Update rows if requested. Add/remove tray notification/info icon
    bool showNotificationArea(bool show, Window* wnd, NamedList* upd = 0,
        const char* notif = "notification");
    // Show a roster change or failure notification
    void showUserRosterNotification(ClientAccount* a, const String& oper,
        Message& msg, const String& contactUri = String::empty(),
        bool newContact = true);
    // Handle actions from notification area. Return true if handled
    bool handleNotificationAreaAction(const String& action, Window* wnd);
    // Save a contact to config. Save chat rooms if the contact is a chat room
    bool storeContact(ClientContact* c);
    // Handle ok from account password/credentials input window
    bool handleAccCredInput(Window* wnd, const String& name, bool inputPwd);
    // Handle channel show/hide transfer/conference toggles
    bool handleChanShowExtra(Window* wnd, bool show, const String& chan, bool conf);
    // Handle conf/transfer start actions in channel item
    bool handleChanItemConfTransfer(bool conf, const String& name, Window* wnd);
    // Handle file share(d) related action
    bool handleFileShareAction(Window* wnd, const String& name, NamedList* params);
    // Handle file share(d) related select
    bool handleFileShareSelect(Window* wnd, const String& name, const String& item,
        const String& text, const NamedList* items);
    // Handle file share(d) item changes from UI
    bool handleFileShareItemChanged(Window* wnd, const String& name, const String& item,
        const NamedList& params);
    // Handle file share(d) drop events
    bool handleFileShareDrop(bool askOnly, Window* wnd, const String& name,
        NamedList& params, bool& retVal);
    // Handle list item change action
    bool handleListItemChanged(Window* wnd, const String& list, const String& item,
        const NamedList& params);
    // Handle drop events
    bool handleDrop(bool askOnly, Window* wnd, const String& name,
        NamedList& params);
    // Handle file share info changed notification
    void handleFileSharedChanged(ClientAccount* a, const String& contact,
        const String& inst);

    ClientAccountList* m_accounts;       // Accounts list (always valid)
    FtManager* m_ftManager;              // Private file manager
};


class YATE_API ClientAccount : public RefObject, public Mutex
{
    friend class ClientContact;
    friend class MucRoom;
    YCLASS(ClientAccount,RefObject)
    YNOCOPY(ClientAccount); // no automatic copies please
public:
    explicit ClientAccount(const char* proto, const char* user, const char* host,
        bool startup, ClientContact* contact = 0);

    explicit ClientAccount(const NamedList& params, ClientContact* contact = 0);

    inline const NamedList& params() const
        { return m_params; }

    inline ObjList& contacts()
        { return m_contacts; }

    inline ObjList& mucs()
        { return m_mucs; }

    inline ClientContact* contact() const
        { return m_contact; }

    void setContact(ClientContact* contact);

    inline const String& protocol() const
        { return m_params[YSTRING("protocol")]; }

    inline bool hasChat() const
        { return protocol() == YSTRING("jabber"); }

    inline bool hasPresence() const
        { return protocol() == YSTRING("jabber"); }

    inline bool startup() const
        { return m_params.getBoolValue(YSTRING("enabled"),true); }

    inline void startup(bool ok)
        { m_params.setParam("enabled",String::boolText(ok)); }

    virtual const String& toString() const
        { return m_params; }

    ClientResource* resource(bool ref);

    inline ClientResource& resource() const
        { return *m_resource; }

    void setResource(ClientResource* res);

    bool save(bool ok = true, bool savePwd = true);

    virtual ClientContact* findContact(const String& id, bool ref = false);

    virtual ClientContact* findContact(const String* name = 0, const String* uri = 0,
        const String* skipId = 0, bool ref = false);

    virtual ClientContact* findContact(const String& id, const String& resid,
        bool ref = false);

    virtual ClientContact* findContactByUri(const String& uri, bool ref = false);

    virtual MucRoom* findRoom(const String& id, bool ref = false);

    virtual MucRoom* findRoomByUri(const String& uri, bool ref = false);

    virtual ClientContact* findAnyContact(const String& id, bool ref = false);

    virtual ClientContact* appendContact(const String& id, const char* name,
        const char* uri = 0);

    virtual ClientContact* appendContact(const NamedList& params);

    virtual ClientContact* removeContact(const String& id, bool delObj = true);

    virtual void clearRooms(bool saved, bool temp);

    virtual Message* userlogin(bool login, const char* msg = "user.login");

    virtual Message* userData(bool update, const String& data,
        const char* msg = "user.data");

    virtual void fillItemParams(NamedList& list);

    inline const String& dataDir() const
        { return m_params[YSTRING("datadirectory")]; }

    virtual bool setupDataDir(String* errStr = 0, bool saveAcc = true);

    virtual bool loadDataDirCfg(Configuration* cfg = 0,
        const char* file = "account.conf");

    virtual void loadContacts(Configuration* cfg = 0);

    virtual bool clearDataDir(String* errStr = 0);

    NamedList m_params;                  // Account parameters
    Configuration m_cfg;                 // Account conf file

protected:
    // Remove from owner. Release data
    virtual void destroyed();
    // Method used by the contact to append itself to this account's list
    virtual void appendContact(ClientContact* contact, bool muc = false);

    ObjList m_contacts;                  // Account's contacts
    ObjList m_mucs;                      // Account's MUC contacts

private:
    ClientResource* m_resource;          // Account's resource
    ClientContact* m_contact;            // Account's contact data
};

class YATE_API ClientAccountList : public String, public Mutex
{
    YCLASS(ClientAccountList,String)
    YNOCOPY(ClientAccountList); // no automatic copies please
public:
    inline explicit ClientAccountList(const char* name, ClientAccount* localContacts = 0)
        : String(name), Mutex(true,"ClientAccountList"),
          m_localContacts(localContacts)
        { }

    ~ClientAccountList();

    inline ObjList& accounts()
        { return m_accounts; }

    inline ClientAccount* localContacts() const
        { return m_localContacts; }

    bool isLocalContact(ClientContact* c) const;

    inline bool isLocalContact(const String& id) const
        { return m_localContacts && m_localContacts->findContact(id); }

    virtual ClientAccount* findAccount(const String& id, bool ref = false);

    virtual ClientContact* findContactByUri(const String& account, const String& uri,
        bool ref = false);

    virtual ClientContact* findContact(const String& account, const String& id, bool ref = false);

    virtual ClientContact* findContact(const String& builtId, bool ref = false);

    virtual ClientContact* findContactByInstance(const String& id, String* instance = 0,
        bool ref = false);

    virtual MucRoom* findRoom(const String& id, bool ref = false);

    virtual MucRoom* findRoomByMember(const String& id, bool ref = false);

    virtual ClientContact* findAnyContact(const String& id, bool ref = false);

    virtual ClientAccount* findSingleRegAccount(const String* skipProto = 0,
        bool ref = false);

    virtual bool appendAccount(ClientAccount* account);

    virtual void removeAccount(const String& id);

protected:
    ObjList m_accounts;

private:
    ClientAccountList() {}               // Avoid using the default constructor
    ClientAccount* m_localContacts;      // Account owning locally stored contacts
};

class YATE_API ClientContact : public RefObject
{
    friend class ClientAccount;
    YCLASS(ClientContact,RefObject)
    YNOCOPY(ClientContact); // no automatic copies please
public:
    enum Subscription {
        SubFrom = 0x01,
        SubTo = 0x02,
    };

    explicit ClientContact(ClientAccount* owner, const char* id, const char* name = 0,
        const char* uri = 0);

    explicit ClientContact(ClientAccount* owner, const NamedList& params, const char* id = 0,
        const char* uri = 0);

    inline ClientAccount* account()
        { return m_owner; }

    inline const String& accountName() const
        { return m_owner ? m_owner->toString() : String::empty(); }

    inline const URI& uri() const
        { return m_uri; }

    inline void setUri(const char* u)
        { m_uri = u; }

    inline const String& subscriptionStr() const
        { return m_subscription; }

    inline bool subscriptionFrom() const
        { return 0 != m_sub.flag(SubFrom); }

    inline bool subscriptionTo() const
        { return 0 != m_sub.flag(SubTo); }

    bool setSubscription(const String& value);

    inline ObjList& resources()
        { return m_resources; }

    inline bool online() const
        { return m_online || 0 != m_resources.skipNull(); }

    inline void setOnline(bool on)
        { m_online = on; }

    inline ObjList& groups()
        { return m_groups; }

    inline bool local(bool defVal = false) const
        { return m_params.getBoolValue(YSTRING("local"),defVal); }

    inline void setLocal(bool on)
        { m_params.setParam("local",String::boolText(on)); }

    inline bool remote(bool defVal = false) const
        { return m_params.getBoolValue(YSTRING("remote"),defVal); }

    inline void setRemote(bool on)
        { m_params.setParam("remote",String::boolText(on)); }

    inline void setDockedChat(bool on) {
            if (!mucRoom())
                m_dockedChat = on;
        }

    inline void getContactSection(String& buf) {
            String pref;
            buf = toString();
            buf.startSkip(buildContactId(pref,accountName(),String::empty()),false);
            buf = buf.uriUnescape();
        }

    virtual const String& toString() const
        { return m_id; }

    virtual MucRoom* mucRoom()
        { return 0; }

    inline String& buildInstanceId(String& dest, const String& inst = String::empty())
        { return buildContactInstanceId(dest,m_id,inst); }

    inline void buildIdHash(String& buf, const String& prefix = String::empty()) {
            MD5 md5(m_id);
            buf = prefix + md5.hexDigest();
        }

    inline bool isChatWnd(Window* wnd)
        { return wnd && wnd->toString() == m_chatWndName; }

    bool hasChat();

    virtual void flashChat(bool on = true);

    virtual bool sendChat(const char* body, const String& res = String::empty(),
        const String& type = String::empty(), const char* state = "active");

    virtual void getChatInput(String& text, const String& name = "message");

    virtual void setChatInput(const String& text = String::empty(),
        const String& name = "message");

    virtual void getChatHistory(String& text, bool richText = false,
        const String& name = "history");

    virtual void setChatHistory(const String& text, bool richText = false,
        const String& name = "history");

    virtual void addChatHistory(const String& what, NamedList*& params,
        const String& name = "history");

    virtual void getChatProperty(const String& name, const String& prop, String& value);

    virtual void setChatProperty(const String& name, const String& prop, const String& value);

    inline bool isChatVisible()
        { return Client::self() && Client::self()->getVisible(m_chatWndName); }

    virtual bool showChat(bool visible, bool active = false);

    Window* getChatWnd();

    virtual void createChatWindow(bool force = false, const char* name = 0);

    virtual void updateChatWindow(const NamedList& params, const char* title = 0,
        const char* icon = 0);

    virtual bool isChatActive();

    void destroyChatWindow();

    virtual String* findGroup(const String& group);

    virtual bool appendGroup(const String& group);

    virtual bool removeGroup(const String& group);

    virtual bool setGroups(const NamedList& list, const String& param);

    virtual ClientResource* status(bool ref = false);

    virtual ClientResource* findResource(const String& id, bool ref = false);

    virtual ClientResource* findAudioResource(bool ref = false);

    virtual ClientResource* findFileTransferResource(bool ref = false);

    virtual ClientResource* appendResource(const String& id);

    virtual bool insertResource(ClientResource* res);

    virtual bool removeResource(const String& id);

    inline NamedList& share()
        { return m_share; }

    inline bool haveShare() const
        { return 0 != m_share.getParam(0); }

    virtual void updateShare();

    virtual void saveShare();

    virtual void clearShare();

    virtual bool setShareDir(const String& name, const String& path, bool save = true);

    virtual bool removeShare(const String& name, bool save = true);

    inline ObjList& shared()
        { return m_shared; }

    bool haveShared() const;

    virtual ClientDir* getShared(const String& name, bool create = false);

    virtual bool removeShared(const String& name = String::empty(), ClientDir** removed = 0);

    static inline String& buildContactId(String& dest, const String& account,
        const String& contact) {
            dest << account.uriEscape('|') << "|" << String::uriEscape(contact,'|').toLower();
            return dest;
        }

    static inline void splitContactId(const String& src, String& account) {
            int pos = src.find('|');
            if (pos >= 0)
                account = src.substr(0,pos).uriUnescape();
            else
                account = src.uriUnescape();
        }

    static void splitContactInstanceId(const String& src, String& account,
        String& contact, String* instance = 0);

    static inline String& buildContactInstanceId(String& dest, const String& cId,
        const String& inst = String::empty()) {
            dest << cId << "|" << inst.uriEscape('|');
            return dest;
        }

    // Chat window prefix
    static String s_chatPrefix;
    // Docked chat window name
    static String s_dockedChatWnd;
    // Docked chat widget name
    static String s_dockedChatWidget;
    // MUC rooms window name
    static String s_mucsWnd;
    // Chat input widget name
    static String s_chatInput;

    String m_name;                       // Contact's display name
    NamedList m_params;                  // Optional contact extra params

protected:
    explicit ClientContact(ClientAccount* owner, const char* id, bool mucRoom);

    void removeFromOwner();

    virtual void destroyed();

    ClientAccount* m_owner;              // The account owning this contact
    bool m_online;                       // Online flag
    String m_id;                         // The contact's id
    String m_subscription;               // Presence subscription state
    Flags32 m_sub;                       // Subscription flags
    URI m_uri;                           // The contact's URI
    ObjList m_resources;                 // The contact's resource list
    ObjList m_groups;                    // The group(s) this contact belongs to
    bool m_dockedChat;                   // Docked chat flag
    String m_chatWndName;                // Chat window name if any
    NamedList m_share;                   // List of files and folders we share
    ObjList m_shared;                    // List of shared. Each entry is a ClientDir whose name is the resource
};

class YATE_API ClientResource : public RefObject
{
    YCLASS(ClientResource,RefObject)
    YNOCOPY(ClientResource); // no automatic copies please
public:
    enum Status {
        Unknown = 0,
        Offline = 1,
        Connecting = 2,
        Online = 3,
        Busy = 4,
        Dnd = 5,
        Away = 6,
        Xa = 7,
    };

    enum Capability {
        CapAudio = 0x00000001,           // Audio
        CapFileTransfer = 0x00000002,    // File transfer support
        CapFileInfo = 0x00000004,        // File info share support
        CapRsm = 0x00000008,             // Result set management support
    };

    inline explicit ClientResource(const char* id, const char* name = 0, bool audio = true)
        : m_id(id), m_name(name ? name : id), m_caps(audio ? CapAudio : 0),
        m_priority(0), m_status(Offline)
        { }

    virtual const String& toString() const
        { return m_id; }

    inline bool online() const
        { return m_status > Connecting; }

    inline bool offline() const
        { return m_status == Offline; }

    inline const char* statusName() const
        { return lookup(m_status,s_statusName); }

    inline const char* text() const
        { return m_text ? m_text.c_str() : statusDisplayText(m_status); }

    inline Flags32& caps()
        { return m_caps; }

    inline bool setAudio(bool ok)
        { return m_caps.changeFlagCheck(CapAudio,ok); }

    inline bool setFileTransfer(bool ok)
        { return m_caps.changeFlagCheck(CapFileTransfer,ok); }

    inline bool setPriority(int prio) {
            if (m_priority == prio)
                return false;
            m_priority = prio;
            return true;
        }

    inline bool setStatus(int stat) {
            if (m_status == stat)
                return false;
            m_status = stat;
            return true;
        }

    inline bool setStatusText(const String& text = String::empty()) {
            if (m_text == text)
                return false;
            m_text = text;
            return true;
        }

    static inline const char* statusDisplayText(int status, const char* defVal = 0)
        { return lookup(status,s_statusName,defVal); }

    static const TokenDict s_statusName[];

    static const TokenDict s_resNotifyCaps[];

    String m_id;                         // The resource id
    String m_name;                       // Resource display name
    Flags32 m_caps;                      // Resource capabilities
    int m_priority;                      // Resource priority
    int m_status;                        // Resource status
    String m_text;                       // Resource status text
};

class YATE_API MucRoomMember : public ClientResource
{
    YCLASS(MucRoomMember,ClientResource)
    YNOCOPY(MucRoomMember); // no automatic copies please
public:
    enum Affiliation {
        AffUnknown = 0,
        AffNone,
        Outcast,
        Member,
        Admin,
        Owner
    };

    enum Role {
        RoleUnknown = 0,
        RoleNone,                        // No role (out of room)
        Visitor,                         // Can view room chat
        Participant,                     // Can only send chat
        Moderator                        // Room moderator: can kick members
    };

    inline explicit MucRoomMember(const char* id, const char* nick, const char* uri = 0)
        : ClientResource(id,nick),
        m_uri(uri), m_affiliation(AffNone), m_role(RoleNone)
        {}

    static const TokenDict s_affName[];

    static const TokenDict s_roleName[];

    String m_uri;                        // Member uri, if known
    String m_instance;                   // Member instance, if known
    int m_affiliation;                   // Member affiliation to the room
    int m_role;                          // Member role when present in room ('none' means not present)
};

class YATE_API MucRoom : public ClientContact
{
    YCLASS(MucRoom,ClientContact)
    YNOCOPY(MucRoom); // no automatic copies please
public:
    explicit MucRoom(ClientAccount* owner, const char* id, const char* name, const char* uri,
        const char* nick = 0);

    inline MucRoomMember& resource()
        { return *m_resource; }

    inline bool ownMember(MucRoomMember* item) const
        { return m_resource == item; }

    inline bool ownMember(const String& item) const
        { return m_resource->toString() == item; }

    inline bool available() const {
            return m_resource->online() &&
                m_resource->m_role > MucRoomMember::RoleNone;
        }

    inline bool canChat() const
        { return available() && m_resource->m_role >= MucRoomMember::Visitor; }

    inline bool canChatPrivate() const
        { return available(); }

    inline bool canChangeSubject() const
        { return available() && m_resource->m_role == MucRoomMember::Moderator; }

    inline bool canInvite() const
        { return available(); }

    bool canKick(MucRoomMember* member) const;

    bool canBan(MucRoomMember* member) const;

    inline Message* buildMucRoom(const char* oper) {
            Message* m = Client::buildMessage("muc.room",accountName(),oper);
            m->addParam("room",uri());
            return m;
        }

    Message* buildJoin(bool join, bool history = true, unsigned int sNewer = 0);

    virtual MucRoom* mucRoom()
        { return this; }

    virtual ClientResource* status(bool ref = false)
        { return (!ref || m_resource->ref()) ? m_resource : 0; }

    MucRoomMember* findMember(const String& nick);

    MucRoomMember* findMember(const String& contact, const String& instance);

    MucRoomMember* findMemberById(const String& id);

    bool hasChat(const String& id);

    virtual void flashChat(const String& id, bool on = true);

    virtual void getChatInput(const String& id, String& text, const String& name = "message");

    virtual void setChatInput(const String& id, const String& text = String::empty(),
        const String& name = "message");

    virtual void getChatHistory(const String& id, String& text, bool richText = false,
        const String& name = "history");

    virtual void setChatHistory(const String& id, const String& text, bool richText = false,
        const String& name = "history");

    virtual void addChatHistory(const String& id, const String& what, NamedList*& params,
        const String& name = "history");

    virtual void setChatProperty(const String& id, const String& name, const String& prop,
        const String& value);

    virtual bool showChat(const String& id, bool visible, bool active = false);

    virtual void createChatWindow(const String& id, bool force = false, const char* name = 0);

    virtual void updateChatWindow(const String& id, const NamedList& params);

    virtual bool isChatActive(const String& id);

    void destroyChatWindow(const String& id = String::empty());

    virtual ClientResource* findResource(const String& id, bool ref = false);

    virtual ClientResource* appendResource(const String& nick);

    virtual bool insertResource(ClientResource* res)
        { return false; }

    virtual bool removeResource(const String& nick, bool delChat = false);

    String m_password;

protected:
    // Release data. Destroy all chats
    virtual void destroyed();

private:
    unsigned int m_index;                // Index used to build member id
    MucRoomMember* m_resource;           // Account room identity and status
};

class YATE_API DurationUpdate : public RefObject
{
    YCLASS(DurationUpdate,RefObject)
    YNOCOPY(DurationUpdate); // no automatic copies please
public:
    inline DurationUpdate(ClientLogic* logic, bool owner, const char* id,
        const char* name, unsigned int start = Time::secNow())
        : m_id(id), m_logic(0), m_name(name),   m_startTime(start)
        { setLogic(logic,owner); }

    virtual ~DurationUpdate();

    virtual const String& toString() const;

    void setLogic(ClientLogic* logic = 0, bool owner = true);

    virtual unsigned int update(unsigned int secNow, const String* table = 0,
        Window* wnd = 0, Window* skip = 0, bool force = false);

    virtual unsigned int buildTimeParam(NamedList& dest, unsigned int secNow,
        bool force = false);

    virtual unsigned int buildTimeString(String& dest, unsigned int secNow,
        bool force = false);

    static unsigned int buildTimeParam(NamedList& dest, const char* param, unsigned int secStart,
        unsigned int secNow, bool force = false);

    static unsigned int buildTimeString(String& dest, unsigned int secStart, unsigned int secNow,
        bool force = false);

protected:
    virtual void destroyed();

    String m_id;                         // Duration's id
    ClientLogic* m_logic;                // Client logic having this object in its list
    String m_name;                       // Widget/column name
    unsigned int m_startTime;            // Start time
};

class YATE_API ClientSound : public String
{
    YCLASS(ClientSound,String)
    YNOCOPY(ClientSound); // no automatic copies please
public:
    inline ClientSound(const char* name, const char* file, const char* device = 0)
        : String(name), m_native(false), m_file(file), m_device(device), m_repeat(0),
        m_started(false), m_stereo(false)
        { }

    virtual ~ClientSound()
        { stop(); }

    virtual void destruct() {
            stop();
            String::destruct();
        }

    inline bool native() const
        { return m_native; }

    inline bool started() const
        { return m_started; }

    inline const String& device() const
        { return m_device; }

    inline void device(const char* dev)
        { Lock lock(s_soundsMutex); m_device = dev; }

    inline const String& file() const
        { return m_file; }

    inline void file(const char* filename, bool stereo)
        { Lock lock(s_soundsMutex); m_file = filename; m_stereo = stereo; }

    inline void setRepeat(unsigned int count)
        { m_repeat = count; }

    inline bool stereo() const
        { return m_stereo; }

    bool start(bool force = true);

    void stop();

    void setChannel(const String& chan, bool ok);

    bool attachSource(ClientChannel* chan);

    static bool build(const String& id, const char* file, const char* device = 0,
        unsigned int repeat = 0, bool resetExisting = true, bool stereo = false);

    static bool started(const String& name);

    static bool start(const String& name, bool force = true);

    static void stop(const String& name);

    static ClientSound* find(const String& token, bool byName = true);

    static ObjList s_sounds;

    static Mutex s_soundsMutex;

    static String s_calltoPrefix;

protected:
    virtual bool doStart();
    virtual void doStop();

    bool m_native;                       // Native (system dependent) sound
    String m_file;
    String m_device;
    unsigned int m_repeat;
    bool m_started;
    bool m_stereo;
    String m_channel;                    // Utility channel using this sound
};

class YATE_API ClientFileItem : public GenObject
{
    YCLASS(ClientFileItem,GenObject)
    YNOCOPY(ClientFileItem); // no automatic copies please
public:
    inline ClientFileItem(const char* name)
        : m_name(name)
        {}

    inline const String& name() const
        { return m_name; }

    virtual ClientDir* directory()
        { return 0; }

    virtual ClientFile* file()
        { return 0; }

    virtual const String& toString() const
        { return name(); }

private:
    ClientFileItem() {}                  // No default constructor
    String m_name;
};

class YATE_API ClientDir: public ClientFileItem
{
    YCLASS(ClientDir,ClientFileItem)
public:
    inline ClientDir(const char* name)
        : ClientFileItem(name), m_updated(false)
        {}

    inline ClientDir(const ClientDir& other)
        : ClientFileItem(other.name()), m_updated(other.updated())
        { copyChildren(other.m_children); }

    inline ObjList& children()
        { return m_children; }

    inline bool updated() const
        { return m_updated; }

    inline void updated(bool on)
        { m_updated = on; }

    bool treeUpdated() const;

    ClientDir* addDir(const String& name);

    ClientDir* addDirPath(const String& path, const char* sep = "/");

    void copyChildren(const ObjList& list);

    void addChildren(ObjList& list);

    bool addChild(ClientFileItem* item);

    ClientFileItem* findChild(const String& path, const char* sep = "/");

    inline ClientFileItem* findChildName(const String& name) {
            ObjList* o = m_children.find(name);
            return o ? static_cast<ClientFileItem*>(o->get()) : 0;
        }

    virtual ClientDir* directory()
        { return this; }

protected:
    ObjList m_children;
    bool m_updated;
};

class YATE_API ClientFile: public ClientFileItem
{
    YCLASS(ClientFile,ClientFileItem)
public:
    inline ClientFile(const char* name, const NamedList* params = 0)
        : ClientFileItem(name), m_params("") {
            if (params)
                m_params.copyParams(*params);
        }

    inline ClientFile(const ClientFile& other)
        : ClientFileItem(other.name()), m_params(other.params())
        {}

    inline NamedList& params()
        { return m_params; }

    inline const NamedList& params() const
        { return m_params; }

    virtual ClientFile* file()
        { return this; }

protected:
    NamedList m_params;
};

}; // namespace TelEngine

#endif /* __YATECBASE_H */

/* vi: set ts=8 sw=4 sts=4 noet: */