I want to trigger a ILaunchListener.launchChanged event from inside an IProcess belonging to the ILaunch
How do I trigger a launchChanged event programatically, in this context?
EDIT: an org.eclipse.debug.core.ILaunch can have afferent processes of type org.eclipse.debug.core.model.IProcess. When something happens inside the IProcess instance I want the ILaunch to access the launchChanged of all the ILaunchListeners registered on the LaunchManager
Related
I would like to install an event handler to execute some code before the nRF52 board goes into deep sleep initiated by the NRF_PWR_MGMT_CONFIG_STANDBY_TIMEOUT_S. Is there a way to call a function either from the shutdown_process() or sd_power_system_off() without modifying the nrf_pwr_mgmt.c file?
I do a remove action through RxJava2 that causes a refresh on my local cache like this:
override fun removeExperience(experienceId: String, placeId: String): Completable {
return from(placesApi.deleteExperience(experienceId, placeId))
.andThen(from(refreshPlace(placeId))
.flatMapCompletable { Completable.complete() }
)
}
so whenever the remove action is done (Completable is complete), a refresh is triggered. The problem is, sometimes this remove action takes long enough for users to just leave the screen, and then the andThen action is never executed cause there is no subscribers anymore, and thus the information on the screen is not up to date anymore.
Is there a way to enforce this action to take place?
Does this logic continue working when user open the same screen again? If so, then you only need to finish subscription from(placesApi.deleteExperience(experienceId, placeId)) on lifecycle events. The easiest way is to add the whole subscription removeExperience() to Disposable or CompositeDisposable and then trigger its .dispose() or .clear() on view stop or destroy events.
.dispose() - doesn't allow to use the same subscription stored.
.clear() - allows re-subscription without creating the new
subscription instance
I want to check if a pdf file is changed or not, and if is changed i want to update the corresponding view. I don't know if it's more suitable to use a background process as a Thread or as an NSOperation to do this task. The Apple Documentation says: "Examples of tasks that lend themselves well to NSOperation include network requests, image resizing, text processing, or any other repeatable, structured, long-running task that produces associated state or data.But simply wrapping computation into an object doesn’t do much without a little oversight".
Also, if I understood correctly from the documentation, a Thread once started can't be stopped during his execution while an NSOperation could be paused or stopped and also they could rely on dependency to wait the completion of another task.
The workflow of this task should be more or less this diagram:
Task workflow
I managed to get the handler working after the notification of type .write has been sent. If i monitor for example a *.txt file everything works as expected and i receive only one notification. But i am monitoring a pdf file which is generated from terminal by pdflatex and thus i receive with '.write' nearly 15 notification. If i change to '.attrib' i get 3 notification. I need the handler to be called only once, not 15 or 3 times. Do you have any idea how can i do it or is not possible with a Dispatch Source? Maybe there is a way to execute a dispatchWorkItem only once?
I have tried to implement it like this(This is inside a FileMonitor class):
func startMonitoring()
{
....
let fileSystemRepresentation = fileManager.fileSystemRepresentation(withPath: fileStringURL)
let fileDescriptor = open(fileSystemRepresentation, O_EVTONLY)
let newfileMonitorSource = DispatchSource.makeFileSystemObjectSource(fileDescriptor: fileDescriptor,
eventMask: .attrib,
queue: queue)
newfileMonitorSource.setEventHandler(handler:
{
self.queue.async
{
print(" \n received first write event, removing handler..." )
self.newfileMonitorSource.setEventHandler(handler: nil)
self.test()
}
})
self.fileMonitorSource = newfileMonitorSource
fileMonitorSource!.resume()
}
func test()
{
fileMonitorSource?.cancel()
print(" restart monitoring ")
startMonitoring()
}
I have tried to reassign the handler in test(), but it's not working(if a regenerate the pdf file, what is inside the new handler it's not executed) and to me, doing in this way, it seems a bit boilerplate code. I have also tried the following things:
suspend the DispatchSource in the setEventHandler of startMonitoring() (passing nil), but then when i am resuming it, i get the remaining .write events.
cancel the DispatchSource object and recall the startMonitoring() as you can see in the code above, but in this way i create and destroy the DispatchSource object everytime i receive an event, which i don't like because the cancel() function shoul be called in my case only when the user decide to disable this feauture i am implementing.
I will try to write better how the workflow of the app should be so you can have an more clear idea of what i am doing:
When the app starts, a functions sets the default value of some checkboxes of the window preference. The user can modify this checkboxes. So when the user open a pdf file, the idea is to launch in a background thread the following task:
I create a new queue call it A and launch asynch an infinite while where i check the value of the UserDefault checkboxe (that i use to reload and update the pdf file) and two things could happen
if the user set the value to off and the pdf document has been loaded there could be two situations:
if there is no current monitoring of the file (when the app starts): continue to check the checkboxe value
if there is currently a monitoring of the file: stop it
if the user set value to on and the pdf document has been loaded in this background thread (the same queue A) i will create a class Monitor (that could be a subclass of NSThread or a class that uses DispatchSourceFileSystemObject like above), then i will call startMonitoring() that will check the date or .write events and when there is a change it will call the handler. Basically this handler should recall the main thread (the main queue) and check if the file can be loaded or is corrupted and if so update the view.
Note: The infinite while loop(that should be running in the background), that check the UserDefault related to the feature i am implementing it's launched when the user open the pdf file.
Because of the problem above (multiple handlers calls), i should use the cancel() function when the user set checkboxe to off, and not create/destroy the DispatchSource object everytime i receive a .write event.
The below portion of my code caused recursive call on onEditorExit method. If I remove setData call, then no recursion occur.
What can be the workaround?
myGrid.addEditorExitHandler(new EditorExitHandler() {
public void onEditorExit(EditorExitEvent event) {
GWT.log("Hello");
myGrid.setData(new ListGridRecord());
}
});
Now check the console output -
Console Screenshot
It won't work because each time you call setData() the editor will fire an editorExit event in an infinite loop (not recursively). By the way, calling setData() in the way you are doing will replace all your records in the ListGrid with one new empty record. This seems like a disconcerting user experience.
It looks like you want to create and start editing a new record when you tab out of the last one. In order to do that in a ListGrid, you use:
grid.setListEndEditAction(RowEndEditAction.NEXT);
That's all you need to do in order to get it working.
I am trying to find the currently selected Project/File and all ways I found so far are using the ISelectionService. The way I found to get an instance of it is:
ISelectionService selectionService = PlatformUI.getWorkbench()
.getActiveWorkbenchWindow().getActivePage();
But unfortunatly .getActiveWorkbenchWindow() returns null since I am not inside the UI-Thread. Is there any good way to get the ISelectionService from outside the UI-Thread?
You can use:
Display.getDefault().synchExec(runnable);
to run a Runnable in the UI thread where you can get the selection service.
However most UI code expects to be run in the UI thread so you may need to use syncExec or asyncExec for anything that is to do with the UI.
Most likely you are following the wrong appraoch. You should obtain the selected project or file before you run the non-UI/background thread.
If your background thread is triggered by a user interaction and should operate on the selected resource (project/file) the selection may well have changed when the thread reaches the point where it queries the selection.
Instead, evaluate the selection on the UI thread and pass the extracted resource as a parameter to your background thread.
For example (simplified code):
// on the UI thread:
IResource resource = ( IResource )getSelectionService().getSelection().getFirstElement();
new Thread( new Runnable() {
public void run() {
resource.copy( ... ); /// or whatever should be done with the resource
}
} ).start();