I'm having a heck of a time trying to get kAudioUnitEvent_ParameterValueChange to work with my custom C++ Audio Unit Host app and a third party 'aumu' unit. I'm loading the unit and displaying the user interfaces just fine. The audio unit is uniquely rare however, in that the plugin is an interface for an external hardware music device. I'm so close but getting weird results.
1) When I change a parameter on the external device, it shows the updated parameter value in the audio unit's custom UI but not in the generic UI. No event changes are notified.
2) When I change a parameter in the custom UI, neither the external hardware or generic UI detect the updated values and still no parameter change events. So nothing was getting change values.
3) When I change a value in the generic UI, everything works properly. I get updated parameter values on both the external device and the custom UI and I'm getting kAudioUnitEvent_ParameterValueChange events.
I'm ultimately trying to get the external device parameters to notify my host app of the event change. My understanding is that Audio Units automatically update parameter values between the UIs and should generate event changes no matter which UI end I use. It seems weird to me that it isn't all being handled automatically. Am I doing something wrong or could this have to do with the Plugin or my Host app?
It seems to work just fine using JUCE pluginHost example but I haven't been able to use JUCE's standalone modules in my project successfully either. Not a lot of Docs on the matter. I've been at this for weeks and just out of ideas.
Related
We tested the fluid framework with minimal requirements.
Everything works fine in the demo application. https://github.com/microsoft/FluidExamples
questions:
How does the Fluid framework work offline?
Our backend is written in asp.net core. The server side of the fluid framework is written in node.js.
How to integrate the asp.net core backend with the fluid service to get the latest document state?
Need to write a driver for a Fluid service?
Offline.
Offline is an interesting topic for CRDTs generally. The Fluid Framework handles intermittent (short) offline scenarios well as long as all the connected clients have the metadata necessary to merge the change in. When the user makes changes, she does so with respect to a minimum sequence number (MinSeq.) If the her offline changes get added to the total order broadcast such that they are above her change's MinSeq, they will be merged with no additional handling.
MinSeq deserves a whole post, but it's the sequence number beneath which all connected clients can garbage collect the metadata necessary to merge changes. Therefore, as long as every client has that metadata, even if you were offline, the merge is easy.
For longer offline scenarios, the reconnecting client could request to lower the MinSeq (probably to the last MinSeq of the offline client.) All clients would then fetch the ops since the requested MinSeq and recreate the metadata. At this point, new changes could easily go in as we have mimicked the scenario where the new changes are above the minimum sequence number.
This could cause temporary perf & memory issues, but hasn't been a problem in reasonable experiments. I don't believe this feature is currently implemented in the Fluid Framework code base, but has been designed as above. (A PR on this topic would be very interesting!)
For even longer offline scenarios, you would probably need a three-way merge. For example: Two users open a document. User A goes on an airplane (loses internet) and writes Macbeth and user B writes Pride & Prejudice, what is the expected behavior when user A rejoins the session? These are entirely incompatible document states, so we'd need to present the users with a dialogue of some sort.
This is not implemented, but we have discussed some of the framework ergonomics of handling the three-way merge (i.e. what APIs would the app developer need.)
Running Fluid in a non NodeJS backend
Document state is managed by the clients and is opaque to the server. There's a similar discussion in this issue. The easiest way to get Fluid Framework document state in an .NET backend would be to run a JS engine and open the Fluid document. You could also run a NodeJS micro service that hosts the Fluid document. This service would have a simple API surface that lets you fetch the data you need.
Recently, I was trying to build a rest service to create, start and stop an integration flow (which was reading an RSS feed and printing on console), and I was able to achieve that.
But my next requirement was to get status (maybe like, running, stopped, stopped with exception) from the already running flow, and I was unable to do that, I cannot see any method related to that in "IntegrationFlowRegistration".
Also, is there a way to store "IntegrationFlow" in RDBMS like MySql, etc?
Well, the flow by itself is just a logical container for components it connects. Even though we really can get somehow access to all those components in one IntegrationFlow, that doesn't mean that your whole solution contains only one IntegrationFlow. It is fully normal to connect components from different IntegrationFlows since at runtime they are fully not related to the IntegrationFlow created them. Those runtime components are identical after any configuration parsing we have in the framework: XML, Java DSL, Kotlin DSL or just plain Java & Annotation configuration. You even can create all the beans manually and still at runtime it is going to be an EIP solution.
What I'm trying to say that it is wrong to try to find a solution for the whole flow state. Or you should consult some individual component (e.g. the mentioned RSS one), or you should have some separate component to track such a custom state.
See Lifecycle contract. Most of Spring Integration implements it, so you can check its isRunning() whenever you need. In fact even a StandardIntegrationFlow implement this one, but you should not fully rely on it because your final solution might consist from several flows or many independent components.
There is no anything like stopped with exception - we don't stop components because of an error. Instead you can enable metrics and check channel or handlers success and failure send counts: https://docs.spring.io/spring-integration/docs/5.3.0.RELEASE/reference/html/system-management.html#metrics-management
I am trying to make a small language learning app using Core Data. Everything is working fine except for one thing: if I use the simulator( iphone SE, for instance) that was selected when I was creating the app, I have got access to all the data from my attributes. But when I switch to another simulator (not an actual device) to run the app , all the attributes look like there are empty, and I do not get nothing.
So if I try to save new data using a different simulator at the top left, i can only get acces to those data only if i run the same simulator that was used to save them.
In a nuthshell, i want to get access to my recorded data no matter what simulator I use.
Can anyone help me solve this problem, please?
Each simulator is independent, and different simulators do not share data. Each one acts like it's a separate simulated device. This isn't about Core Data-- it would be the same for any data your app saves. There's no good way to share data between simulators. Some command-line Unix wizardry might get shared files but it's not built in or supported.
I am using the Android SDK for Nest, but I believe this is a general Nest question so I did not tag this question with Android.
When registering a GlobalUpdate listener, I cannot find any API to tell me why it was called, or what changed. The documentation says,
GlobalUpdate contains the state of all devices, structures and metadata in the Nest account when a change is detected in anything
It would be nice if there was a field to know what that change was. Is there a better way than tracking all of the data myself and comparing it?
Hi I'm the author of the Nest Android SDK. This SDK (and the Nest API itself) provides the entire state (and omits saying what changes were made) every time for a number of reasons:
Clients may have older (or newer!) data than what the server has, so stating the changes would result in the client incorrectly determining the "true" state.
This design ensures that everyone (all clients and the server) become eventually consistent, and haven't combined changes in an order that results in up to date clients with different states.
You can always calculate the changes yourself and update your UI state accordingly, but every event that your client receives should be independent of each other and shouldn't depend on assumed knowledge of the prior state.
Can anyone explain any reason why and when should I use PublishOnBackgroundThread instead of PublishOnUIThread.
I cannot find any use cases for usage PublishOnBackgroundThread and I am not sure what method should I use?
It really depends on the type of the message you're publishing.
If you're using the EventAggregator to surface a message from a low laying service back the UI then PublishOnUIThread makes the most sense since you'll be updating the UI when handling the message. The same applies when you're using it to communicate between view models.
Conversely sometimes it get used for view models to publish events that an underlying service is listening to (rather than the view model depending on that service).
That service may perform some expensive work which makes sense to happen on a background thread. Personally I'd have gone in the background service to push that work onto a background thread but different people want different options.
Ultimately the method was included for completeness.