ObjectPath | The agile query language for semi-structured data | Crawler library

From the debug output it appears that ConnMan is doing a MethodCall, but QDBusConnection::connect() is for handling DBus singals, which is why your slot is not invoked.

You need to register an object implementing the net.connman.Agent interface onto the corresponding path, so that ConnMan can invoke your methods:

I did resolve, to some degree, my original post's questions and frustrations by using the ffmpeg_kit_flutter_full_gpl package on the client side, and then ffmpeg again in GCF on the server side. In summary:

• Within 60 seconds, I can now compress a 2 minute video by 90% before uploading to firebase storage.
• Using onFinalize via GCF on the server side I run ffmpeg again on the uploaded video and gain another 77% reduction in file size on the server side without any loss in video quality.
• My solution does not yet upload while the app is closed.
• On the client side, this solution requires setting the camera ResolutionPreset to high (720p), rather than max, which can be a minimum of 1080p, and setting the ffmpeg -preset veryfast rather than the medium default.

Camera & ffmpeg solution settings:

• Flutter camera package ResolutionPreset to high
• ffmpeg -preset veryfast

Transcoding results stats for 2 minute video:

• Before transcode: 255MB
• After client side transcode: 25MB (90% decrease in size before upload)
• Time to transcode: 60 seconds
• onFinalized GCF ffmpeg transcode: 19MB (77% reduction in size)
• In total a 93% reduction in size while keep high quality 720p video.

flutter_ffmpeg is archived, the new ffmpeg flutter package is ffmpeg_kit_flutter.

That being said, I used ffmpeg_kit_flutter to build my solution on the client side, rather than the server side, and transcode the video before uploading.

Cons:

1. Doubled my app size to use ffmpeg, because I needed access to both lame and x264 so I had to install the full-gpl package to gain access to these libraries.
2. A two minute video can take up to 60 seconds to transcode.

The pros:

1. Low bandwidth connections will operate much better after a video is reduced in size by 90%.
2. Large videos will transcode and ffmpegkit does not crash like other flutter packages I've tried.
3. The second pass with ffmpeg on GCF gains another 77% reduction in size taking a video of 100's of MB's down to just 10-20 MB max for eventually delivery.
4. Costs lower on the front and back end.

So, you'll have to decide if the pros outweighs the cons and if 720p is high enough quality for playback. For me 720p looks perfect for video playback on a mobile phone and 1080p or higher was big time overkill.

I've provided sample code (not full classes) to give anyone looking to implement my solution a try. It became very important, due to the amount of time to transcode, to display a progress meter so the user does not give up on the process. You'll see my simple solution to displaying transcoding progress.

pubspec.yaml

• camera package for video recording
• riverpod required for statenotifier and transcode/upload progress notifications
• ffmpeg_kit_flutter_full_gpl (the full_gpl gets the ffmpeg package with most libraries) required to get h264 and libmp3lame encoders to produce most widely playable transcoded videos.
• wakelock required because transcoding takes so long you don't want the phone to sleep while transcoding.

The problem with this kind of function is that it's inherently not type-safe. You're providing the object path as a string, assuming that string is valid for the given object (and there's no way to avoid that being an assumption), and returning whatever value you end up on. FWIW, I'd suggest not using it. Instead, use optional chaining (and when needed, nullish coalescing):

From what I can see, for each Depot, there is at most one Acte and one Vente. So what you're trying to do is a bit exotic, as filtering in sorts is generally used on multi-valued nested objects.

The reason it's not working is you didn't mark the @IndexedEmbedded objects (vente, acte) as "nested"; as explained in the documentation, filtering only works on nested objects. And "nested" has a very precise meaning, it's not synonmymous with "indexed-embedded".

However, I think the whole approach is wrong in this case: you shouldn't use filtering. I'm quite sure that even if you mark the @IndexedEmbedded objects as "nested", you will face other problems, because what you're trying to do isn't the intended purpose of filtering. One of those problems could be performance; nested documents mean runtime joins, and runtime joins aren't cheap.

Instead, consider solving this problem at indexing time. Instead of trying to figure out which date to use for each document when searching, do that when indexing:

You can use JSON.parse with a "reviver" that recursively tries to parse every decoded string as json (and returns the argument as is if that fails):

When a Status entity is modified, Hibernate Search doesn't know how to retrieve the corresponding Person having that Status as its currentStatus.

Assuming the currentStatus is always contained in status, and since Status.patient is the inverse side of the Person.status association, you should only need to add this:

Something like?

Oh! I am pretty sure you are supposed to send a pointer to an integer (not a pointer to a pointer to it).

You can do

gint32 handle; // instead of gint32 *handle;

and it should work.

This API has a very poor design (relying on variadic, with format specifiers... the reason why people dislike C).

You need to use correct aliases in the first select statement: