For my project I want to access the data from as many bug- and work-item repositories as possible (for development in Eclipse). Therefore I use the Mylyn plugin because it already provides a framework for efficient use of multiple sources.
If I found out right, the tasks are saved under .metadata\.mylyn\tasks.xml.zip\tasklist.xml and .metadata\.mylyn\tasks\<folder>\<id>.zip\data.xml. But I don't know how to access the data and get changes...
Is there a possibility to receive a notification if a task changes (e.g. if a work item status changes from CONFIRMED to SOLVED)?
Is it somehow possible to subscribe to the Mylyn event which shows a little notification if something changes? Or is there something like an eventlogger or resource change listener?
Thank you!
Mylyn has all of this data accessible by a variety of API's. You can use the ITaskDataManager API (accessible via TasksUi.getTaskDataManager()) to get the full task data for a given task. You can listen for changes to when the task data is updated (e.g. there was a change to a task) using the ITaskDataManagerListener and attaching your listener to the TaskDataManager, then you can look at the task data to get what the values of the fields that you are interested in are. To see how the notification popup uses this, you can look at the TaskListNotifier.
Feel free to email mylyn-integrators#eclipse.org if you have more questions.
Related
I have tried to find out a new updated Stickerview library but no updated library available on GitHub.
https://github.com/kencheung4/android-StickerView
https://github.com/nimengbo/StickerView
All the Above library not working well.
Functionality Needed:
Auto Face detects and applies the sticker on it very well.
Multiple stickers can add/replace at a time.
Please suggests how to look for a good library for Stickerview.
(This is not a request for finding a tool)
You can refer to the "Network" section of those two repositories:
https://github.com/kencheung4/android-StickerView/network
https://github.com/nimengbo/StickerView/network
You will see the forks created from said repositories, and the newer commits done in those forks.
That way, you might find the one fork which include the fixes you want.
For example: usmanrana07/android-StickerView includes:
Added 'controlFrameVisibility' method
The controller frame should hide after particular time of ACTION_UP even because if user wants to take screenshot then those icons also remain visible in picture.
I have added pieces of code which will hide the controller frame after 2 seconds of action completion and it would be visible again on touch to the view.
And yongjhih/StickerView adds a StickerManager for simpler application, which could be of interest in your case.
There might not be the exact features you are looking for, but the "Network" section is a good way to assess if said features were already coded, or if you need to implement them.
How do I create a snapshot of running java application in order to be able to load the same snapshot later to recreate exactly the same state of running application? How do I load this snapshot?
EDIT
Application uses Event Sourcing, we have event log which can be replayed to get to a particular application state, however we'd like to archive the log and only retain the latest application state in a snapshot which we'd like to load instead of replaying all of the events from event log.
I think you can serialize part of your data and deserialize it later on. Also, you need to think about common patterns (e.g. Command) and use them in your app. This will help you to do serialization of app's behavior or processing flow (even on half way of processing of data).
There is a great library from Martin Krasser which does exactly that - keeps state using event sourcing and also allows for event log snapshots: https://github.com/eligosource/eventsourced
I am working with eclipse resources right now and interested whether it is possible to handle file read-only property change ? For example user changes file read-only property outside application and then I can handle this property change event in my application.
I don't think, it is possible to do it automatically, as Eclipse resources do not synchronize all the time with the file system. More specifically, file changes do not trigger events in the Eclipse resources directly. Files are refreshed only when the resources are read.
Maybe if you are refreshing continously, it would be possible, but that can have quite an overhead. After a refresh it is possible to listen to changes in resources - thats what Builders and resource listeners are for.
To be more precise than Zoltan's answer:
No, it is not possible to do this directly. However, it is possible to periodically refresh the workspace and look for changes that you are interested in.
Create and schedule a Job that runs every XXX seconds. This job will run IProject.refreshLocal(IResource.DEPTH_INFINITE, null). After running this operation, it will re-schedule itself to run in another XXX seconds.
Add an IResourceChangeListener that listens for the changes you are interested in.
Now, if the Read-only changes happen from inside the workspace, you will not have to do #1, and #2 (the resource change listener) will run automatically.
In Intellij IDEA 9 or 10, is there something akin to a persistent changelist? I'd like to continue to monitor a list of files after the commit; I'd like to continue making updates based upon a single use case or (JIRA) ticket.
Favorites are not as intuitive as changelists as they cannot group units of work into separate concerns. It's a single list I have to actively maintain. In addition, I'd like to be able to track a file separately across multiple changelists.
Lastly, I've looked around for a plugin that may accomplish this, but haven't found anything.
Thanks for your help.
There is probably another way to it using Idea's contexts. Navigate to the Tools -> Contexts in the menu and save your current context. When you will need it back then just load it. More information on contexts is available in the idea's help.
Note to future readers: Circa 2016, Changelists are now persistent by default, with a dialog prompting you to turn on auto-deletion of empty changelists.
They automagically incorporate both tasks and contexts, allowing you to manage all three together conveniently.
Alternately, you can navigate to Tools -> Tasks & Contexts -> Open Task or press Alt+Shift+N and enter a new or existing task name; when creating a new task, it offers to create a changelist for you; and, it offers to copy the current context, or start fresh.
After further searching, I found a plugin to do exactly as I needed.
Chris Bartley's Workspaces:
http://plugins.intellij.net/plugin/?id=83
I am doing a keyboard for Android.
I am willing to have a plugin structure to allow users to improve the prediction engine.
The prediction engine is done with Android NDK and it was coded in C. I have a wrapper class that calls the C code. An instance of this wrapper class is a field in the InputMethodService.
The prediction engine gets updated by sending complete sentences. Something like:
public void updateEngine(String sentence);
Plugins should be calling that method.
An example of the plugin can be a .txt parser. You select a txt file and the plugin will start sending to the main app all sentences.
I would like plugins to be customizable, e.g.: They might have an screen where you can choose max sentence to send, to run on background, etc.
The UI (don't know if it should be on the main app or the plugin, check my questions below) should have the possibility to ask the plugin how many sentence it can send (to do a progress bar).
My questions are:
Should I use Intents or IPC?
I think I should use Intents since I just use primitive types.
Should my operations be atomic or send an array of sentences?
I am willing to start with atomic operations but I am worried about performance.
The plugins must be activities or Services?
They should be Activities and if necessary ("process on background" on) launch a service. Or perhaps they are just services and the main app takes care of the UI.
Who should save information about the last execution. Plugin or the mainApp?
e.g. When was the last time the plugin was used.
Should I use Intents or IPC?
Either works. Intents may be simpler.
Should my operations be atomic or send
an array of sentences?
I'd bundle these up into a single operation if possible. Lots of little cross-process trips is more expensive than one large one, as I understand it.
The plugins must be activities or
Services?
You appear to want the plugin to call into the engine, which is fine, but...when? Plugins won't get control automatically at install time. The choice of trigger mechanism for the plugin calling into the engine will dictate whether the plugin needs an activity or not.
Who should save information about the
last execution. Plugin or the mainApp?
This doesn't make a lot of sense to me given the rest of what you have here, so I can't comment. This may roll back to the lack-of-trigger issue I mention above. For example, under what circumstances would a plugin ever be used more than once?