package im.pidgin.libpurple.core;

/**

* Objects that use this class belong to a purple instance, which is referenced

* by the main manager.

* @author michaelz

*/

private final CoreManager manager;

public AbstractPurpleManaged(CoreManager manager) {

this.manager = manager;

}

protected CoreManager getManager() {

return manager;

}

* This is the core purple manager, that provides access to all functionality.

* <p>

* It also implements the core UI ops.

*/

public class CoreManager {

private final PurpleAccountManager accountList = new PurpleAccountManager(

private final EventLoop eventloop = new EventLoop(this);

private final PurpleThread purpleThread = new PurpleThread();

private final PurpleBlistManager blist = new PurpleBlistManager(this);

/**

* Initializes libpurple by setting all the ui ops and calling

* purple_core_init().

* @param uiName

* The name of the UI.

*/

public boolean startCore(String uiName, File baseDirectory) {

eventloop.register();

private native boolean startCore_native(String uiName, String baseDirectory);

public EventLoop getEventloop() {

return eventloop;

}

new RequestUiOps().register();

}

public PurpleThread getThread() {

return purpleThread;

}

public PurpleAccountManager getAccountList() {

return accountList;

}

public PurplePluginList getPluginManager() {

return pluginManager;

}

public PurpleBlistManager getBlist() {

return blist;

}

public ConversationManager getConversationManager() {

return conversationManager;

}

/**

* This is the eventloop implementation that is used to schedule libpruple

* events on the purple thread.

* @author michaelz

*/

public class EventLoop extends AbstractPurpleManaged {

private final Object scheduledTimersMutex = new Object();

private int timeoutCounter = 0;

public EventLoop(CoreManager manager) {

/**

* Should create a callback timer with an interval measured in milliseconds.

* The supplied function should be called every interval seconds until it

* @param interval

* the interval in milliseconds between calls to function.

* @param function

key = timeoutCounter;

System.out.println("Adding eventloop task " + key

if (interval <= 0) {

interval = 1;

}

}

/**

* @param handle

* an identifier for a timeout, as returned by timeout_add.

* @return TRUE if the timeout identified by handle was found and removed.

/**

* This is a {@link WaitableRunnable} that executes the given function.

* @author michaelz

*/

private class EventloopFunctionExecutor extends AbstractWaitableRunnable {

private final long function;

private native boolean exeucte_native(long function, long data);

public void ioInvoke(long function, long data, int fd, int cond) {

}

private static class IoInvokeRunner extends AbstractWaitableRunnable {

private final long function;

private final long data;

ioInvoke_native(function, data, fd, cond);

}

}

}

/**

* This is a special task for the eventloop.

* @author michaelz

*/

public class EventloopTask extends TimerTask {

private final WaitableRunnable runnable;

private final PurpleThread thread;

public EventloopTask(WaitableRunnable runnable, PurpleThread thread) {

* interrupted.

*/

System.err.println("Unexpected interupt exception"

}

}

import im.pidgin.libpurple.peering.Peered;

/**

* Objects that use this class belong to a purple instance, which is referenced

* by the main manager.

* @author michaelz

*/

private final CoreManager manager;

public PeeredPurpleManaged(long nativePointer, CoreManager manager) {

super(nativePointer);

this.manager = manager;

}

protected CoreManager getManager() {

return manager;

}

* libpurple instance.

* <p>

* There can only be one instance per process.

* @author michaelz

*/

public class PurpleInstance {

private static Object instanceActiveMutex = new Object();

private static boolean instanceActive = false;

private final CoreManager coreManager = new CoreManager();

/**

* Creates a new instance and loads libpurple. This might take some time.

* @param uiName

* @param baseDirectory

*/

PurpleLibraryLoader.load();

setDebugEnabled(true);

File pluginDirectory = new File(baseDirectory, "plugins");

if (!pluginDirectory.exists()) {

pluginDirectory.mkdirs();

if (!coreManager.startCore(uiName, baseDirectory)) {

throw new PurpleRuntimeException(

}

}

public void setDebugEnabled(boolean enabled) {

setDebugEnabled_native(enabled);

}

private native void setDebugEnabled_native(boolean enabled);

public void addPluginSearchpath(File directory) {

addPluginSearchpath_native(directory.getAbsolutePath());

}

private native void addPluginSearchpath_native(String absolutePath);

public static PurpleInstance createInstance(String uiName,

synchronized (instanceActiveMutex) {

if (instanceActive) {

throw new IllegalStateException(

}

instanceActive = true;

}

/**

* Gets the current version of libpurple.

* @return The version as version String.

*/

public String getVersion() {

}

private native String getVersion_native();

public PurpleAccountList getAccountList() {

return coreManager.getAccountList();

}

public PurplePluginList getPluginList() {

return coreManager.getPluginManager();

}

public PurpleBlist getBlist() {

return coreManager.getBlist();

}