notifier | Fast to config , easy to to deploy notification server | Notification library

It seems, Kotlin’s println(…) function has a different behavior than Java’s System.out.println(…) statement, regarding the order of evaluation.

In Java when you write

The core of the problem here is that Success and Notifier are both structurally the same, so TypeScript thinks that if the following if statement has a chance of returning true for one of those classes, it would return true for both:

if(result.isFailure())

Hence, the result value type after this block is automatically inferred as never. I have created an example to illustrate this here.

This problem can easily be fixed by introducing a unique field/method within one of the two classes or alternatively adding a private field/method.

The explanation above will fix the issue you are having and can be used to describe the behaviour of the if(result.isFailure()) statement. However, if(result.isSuccess()) on the other hand still appears to work with your original code. The reason for that is because you have introduced dynamicity in the order of how the nested generic types are assigned to the extending classes:

extends ResultAbstract vs extends ResultAbstract

Given the above, the classes can be considered to be different, however TypeScript will still think that Success and Notifier are the same as the is predicates tell it that Success can be Notifier (via the isFailure method) and Notifier can be Success (via the isSuccess method). Hence, all you need to do is remove either the isSuccess or the isFailure method and the code will start to work as it will tell TypeScript that it can only be one. Because your code only uses two classes, this would be the most suitable solution.

symfony-cmd is a part of Symfony Flex. Your composer.json does not contain any requirement for Flex, so running composer require symfony/flex might resolve that problem.

Hi please have a look at this discussion: https://github.com/flutter/flutter/issues/70436

• on on the image picker package site we can see that it is a well known apple simulator issue. I would say that it should work for you on real devices (or try to test it only with particular pictures from iOS simulator photos)

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.

While adding data, set listen:false

XFile is a image_picker package's wrapper for the picked file(s). Hence, you obtain a List from await ImagePicker().pickMultiImage() call, but try to assign it to a _selectedPostImages field that expects List which produces the type mismatch error.

So, you can either:

1. Rewrite the _selectedPostImages to expect List, like List? _selectedPostImages.
2. Map the _imageList to a list of File, like _selectedPostImages = _imageList.map((xfile) => File(xfile.path)).toList()

I believe this is a simple use case of the throttle() operator.

I had the same problem with literally the exact same number of vulnerabilities.

Check out the solution here