Use this SDK to add realtime video, audio and data features to your Flutter app. By connecting to LiveKit Cloud or a self-hosted server, you can quickly build applications such as multi-modal AI, live streaming, or video calls with just a few lines of code.

This package is published to pub.dev as livekit_client.

More Docs and guides are available at https://docs.livekit.io

LiveKit client SDK for Flutter is designed to work across all platforms supported by Flutter:

• Android
• iOS
• Web
• macOS
• Windows
• Linux

We built a multi-user conferencing app as an example in the example/ folder. LiveKit is compatible cross-platform: you could join the same room using any of our supported realtime SDKs.

Online demo: https://livekit.github.io/client-sdk-flutter/

Include this package to your pubspec.yaml

---
dependencies:
  livekit_client: <version>

Camera and microphone usage need to be declared in your Info.plist file.

<dict>
  ...
  <key>NSCameraUsageDescription</key>
  <string>$(PRODUCT_NAME) uses your camera</string>
  <key>NSMicrophoneUsageDescription</key>
  <string>$(PRODUCT_NAME) uses your microphone</string>

Your application can still run the voice call when it is switched to the background if the background mode is enabled. Select the app target in Xcode, click the Capabilities tab, enable Background Modes, and check Audio, AirPlay, and Picture in Picture.

Your Info.plist should have the following entries.

<dict>
  ...
  <key>UIBackgroundModes</key>
  <array>
    <string>audio</string>
  </array>

Since xcode 14 no longer supports 32bit builds, and our latest version is based on libwebrtc m104+ the iOS framework no longer supports 32bit builds, we strongly recommend upgrading to flutter 3.3.0+. if you are using flutter 3.0.0 or below, there is a high chance that your flutter app cannot be compiled correctly due to the missing i386 and arm 32bit framework #132 #172.

You can try to modify your {projects_dir}/ios/Podfile to fix this issue.

post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)

    target.build_configurations.each do |config|

      # Workaround for https://github.com/flutter/flutter/issues/64502
      config.build_settings['ONLY_ACTIVE_ARCH'] = 'YES' # <= this line

    end
  end
end

For iOS, the minimum supported deployment target is 12.1. You will need to add the following to your Podfile.

platform :ios, '12.1'

You may need to delete Podfile.lock and re-run pod install after updating deployment target.

We require a set of permissions that need to be declared in your AppManifest.xml. These are required by Flutter WebRTC, which we depend on.

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.your.package">
  <uses-feature android:name="android.hardware.camera" />
  <uses-feature android:name="android.hardware.camera.autofocus" />
  <uses-permission android:name="android.permission.CAMERA" />
  <uses-permission android:name="android.permission.RECORD_AUDIO" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
  <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
  <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
  ...
</manifest>

For using the bluetooth headset correctly on the android device, you need to add permission_handler to your project. And call the following code after launching your app for the first time.

import 'package:permission_handler/permission_handler.dart';

Future<void> _checkPermissions() async {
  var status = await Permission.bluetooth.request();
  if (status.isPermanentlyDenied) {
    print('Bluetooth Permission disabled');
  }
  status = await Permission.bluetoothConnect.request();
  if (status.isPermanentlyDenied) {
    print('Bluetooth Connect Permission disabled');
  }
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await _checkPermissions();
  runApp(MyApp());
}

By default, we use the communication audio mode on Android which works best for two-way voice communication.

If your app is media playback oriented and does not need the use of the device’s microphone, you can use the media audio mode which will provide better audio quality.

import 'package:flutter_webrtc/flutter_webrtc.dart' as webrtc;

Future<void> _initializeAndroidAudioSettings() async {
  await webrtc.WebRTC.initialize(options: {
    'androidAudioConfiguration': webrtc.AndroidAudioConfiguration.media.toMap()
  });
  webrtc.Helper.setAndroidAudioConfiguration(
      webrtc.AndroidAudioConfiguration.media);
}

void main() async {
  await _initializeAudioSettings();
  runApp(const MyApp());
}

Note: the audio routing will become controlled by the system and cannot be manually changed with functions like Hardware.selectAudioOutput.

In order to enable Flutter desktop development, please follow instructions here.

On Windows VS 2019 is needed (link in flutter docs will download VS 2022).

final roomOptions = RoomOptions(
  adaptiveStream: true,
  dynacast: true,
  // ... your room options
)

final room = Room();

// you can use `prepareConnection` to speed up connection.
await room.prepareConnection(url, token);

await room.connect(url, token, roomOptions: roomOptions);

try {
  // video will fail when running in ios simulator
  await room.localParticipant.setCameraEnabled(true);
} catch (error) {
  print('Could not publish video, error: $error');
}

await room.localParticipant.setMicrophoneEnabled(true);

Screen sharing is supported across all platforms. You can enable it with:

room.localParticipant.setScreenShareEnabled(true);

On Android, you will have to use a media projection foreground service.

In our example, we use the flutter_background package to handle this. In the app’s AndroidManifest.xml file, declare the service with the appropriate types and permissions as following:

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <!-- Required permissions for screen share -->
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
  <application>
    ...
    <service
        android:name="de.julianassmann.flutter_background.IsolateHolderService"
        android:enabled="true"
        android:exported="false"
        android:foregroundServiceType="mediaProjection" />
  </application>
</manifest>

Before starting the background service and enabling screen share, you must call Helper.requestCapturePermission() from flutter_webrtc, and only proceed if it returns true. Refer to our example implementation for details.

On iOS, a broadcast extension is needed in order to capture screen content from other apps. See setup guide for instructions.

On dekstop you can use ScreenSelectDialog to select the window or screen you want to share.

try {
  final source = await showDialog<DesktopCapturerSource>(
    context: context,
    builder: (context) => ScreenSelectDialog(),
  );
  if (source == null) {
    print('cancelled screenshare');
    return;
  }
  print('DesktopCapturerSource: ${source.id}');
  var track = await LocalVideoTrack.createScreenShareTrack(
    ScreenShareCaptureOptions(
      sourceId: source.id,
      maxFrameRate: 15.0,
    ),
  );
  await room.localParticipant.publishVideoTrack(track);
} catch (e) {
  print('could not publish screen sharing: $e');
}

LiveKit supports end-to-end encryption for audio/video data sent over the network. By default, the native platform can support E2EE without any settings, but for flutter web, you need to use the following steps to create e2ee.worker.dart.js file.

# for example app
dart compile js web/e2ee.worker.dart -o example/web/e2ee.worker.dart.js -m
# for your project
export YOU_PROJECT_DIR=your_project_dir
git clone https://github.com/livekit/client-sdk-flutter.git
cd client-sdk-flutter && flutter pub get
dart compile js web/e2ee.worker.dart -o ${YOU_PROJECT_DIR}/web/e2ee.worker.dart.js -m

The setCameraEnabled/setMicrophoneEnabled helpers are wrappers around the Track API.

You can also manually create and publish tracks:

var localVideo = await LocalVideoTrack.createCameraTrack();
await room.localParticipant.publishVideoTrack(localVideo);

Each track can be rendered separately with the provided VideoTrackRenderer widget.

VideoTrack? track;

@override
Widget build(BuildContext context) {
  if (track != null) {
    return VideoTrackRenderer(track);
  } else {
    return Container(
      color: Colors.grey,
    );
  }
}

Audio tracks are played automatically as long as you are subscribed to them.

LiveKit client makes it simple to build declarative UI that reacts to state changes. It notifies changes in two ways

• ChangeNotifier – generic notification of changes. This is useful when you are building reactive UI and only care about changes that may impact rendering.
• EventsListener<Event> – listener pattern to listen to specific events (see events.dart).

This example will show you how to use both to react to room events.

class RoomWidget extends StatefulWidget {
  final Room room;

  RoomWidget(this.room);

  @override
  State<StatefulWidget> createState() {
    return _RoomState();
  }
}

class _RoomState extends State<RoomWidget> {
  late final EventsListener<RoomEvent> _listener = widget.room.createListener();

  @override
  void initState() {
    super.initState();
    // used for generic change updates
    widget.room.addListener(_onChange);

    // used for specific events
    _listener
      ..on<RoomDisconnectedEvent>((_) {
        // handle disconnect
      })
      ..on<ParticipantConnectedEvent>((e) {
        print("participant joined: ${e.participant.identity}");
      })
  }

  @override
  void dispose() {
    // be sure to dispose listener to stop listening to further updates
    _listener.dispose();
    widget.room.removeListener(_onChange);
    super.dispose();
  }

  void _onChange() {
    // perform computations and then call setState
    // setState will trigger a build
    setState(() {
      // your updates here
    });
  }

  @override
  Widget build(BuildContext context) {
    // your build function
  }
}

Similarly, you could do the same when rendering participants. Reacting to changes makes it possible to handle tracks published/unpublished or re-ordering participants in your UI.

class VideoView extends StatefulWidget {
  final Participant participant;

  VideoView(this.participant);

  @override
  State<StatefulWidget> createState() {
    return _VideoViewState();
  }
}

class _VideoViewState extends State<VideoView> {
  TrackPublication? videoPub;

  @override
  void initState() {
    super.initState();
    widget.participant.addListener(this._onParticipantChanged);
    // trigger initial change
    _onParticipantChanged();
  }

  @override
  void dispose() {
    widget.participant.removeListener(this._onParticipantChanged);
    super.dispose();
  }

  @override
  void didUpdateWidget(covariant VideoView oldWidget) {
    oldWidget.participant.removeListener(_onParticipantChanged);
    widget.participant.addListener(_onParticipantChanged);
    _onParticipantChanged();
    super.didUpdateWidget(oldWidget);
  }

  void _onParticipantChanged() {
    var subscribedVideos = widget.participant.videoTracks.values.where((pub) {
      return pub.kind == TrackType.VIDEO &&
          !pub.isScreenShare &&
          pub.subscribed;
    });

    setState(() {
      if (subscribedVideos.length > 0) {
        var videoPub = subscribedVideos.first;
        // when muted, show placeholder
        if (!videoPub.muted) {
          this.videoPub = videoPub;
          return;
        }
      }
      this.videoPub = null;
    });
  }

  @override
  Widget build(BuildContext context) {
    var videoPub = this.videoPub;
    if (videoPub != null) {
      return VideoTrackRenderer(videoPub.track as VideoTrack);
    } else {
      return Container(
        color: Colors.grey,
      );
    }
  }
}

On LocalTrackPublications, you could control if the track is muted by setting its muted property. Changing the mute status will generate an onTrackMuted or onTrack Unmuted delegate call for the local participant. Other participant will receive the status change as well.

// mute track
trackPub.muted = true;

// unmute track
trackPub.muted = false;

When subscribing to remote tracks, the client has precise control over status of its subscriptions. You could subscribe or unsubscribe to a track, change its quality, or disabling the track temporarily.

These controls are accessible on the RemoteTrackPublication object.

Please join us on Slack to get help from our devs / community members. We welcome your contributions(PRs) and details can be discussed there.

Apache License 2.0

A huge thank you to flutter-webrtc for making it possible to use WebRTC in Flutter.

Download and/or contribute to the Flutter package on GitHub

The post Flutter Client SDK for LiveKit appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

PrepPDF App

PrepPDF is a Flutter application designed to provide structured access to previous year question papers and solutions. With a user-friendly interface, this app simplifies the way students prepare for exams.

Linkdin Posts of This Project https://shorturl.at/VmzNI

• Firebase Authentication: Secure user login and registration.
• Payment Gateway Integration: Seamless payments using Razorpay for premium features.
• Push Notifications: Stay updated with the latest exam-related information.
• Light and Dark Theme: Switch between light and dark modes for a comfortable user experience.
• Store User Data in Firestore: Safely store user data in the cloud.
• User-Friendly UI: Simple and intuitive design for easy navigation.

1. User Registration/Login: Users can sign up or log in using Firebase Authentication.
2. Browse PDFs: Access previous year question papers, organized by subjects and years.
3. Notifications: Receive updates about new content or features directly via push notifications.
4. Theme Toggle: Switch between light and dark themes as per your preference.
5. Payments: Purchase premium content easily through Razorpay integration.
6. Update User Information: Users can update their personal information, such as name and year, stored in Firestore.

• firebase_auth: User authentication using Firebase.
• cloud_firestore: Storing and retrieving user data.
• firebase_storage: Hosting PDFs on Firebase Storage.
• easy_pdf_viewer: Viewing PDF documents.
• provider: State management for a smoother app experience.
• firebase_messaging: Push notifications to keep users informed.
• firebase_analytics: Tracking user interactions.
• razorpay_flutter: Payment gateway for in-app purchases.
• flutter_dotenv: Managing environment variables.

Download Source code on GitHub

The post PrepPDF app provides organised access to previous year question papers and solutions appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Description

The project is a Dart library for SMS verification codes.

verification_code:^0.0.4

   VerificationCode(
      height: 50,
      style: CodeStyle.form,
      maxLength: 4,
      itemWidth: 50,
      onCompleted: (String value) {
          print("CodeStyle.form value=$value");
      },
    ),

Download source code on GitHub

The post The project is a Flutter library for SMS verification codes appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Thank you for considering contributing to OpSo! We welcome contributions from the community to help improve the app and add new features. Below are some guidelines for contributing:

If you encounter any bugs or have ideas for new features, please open an issue on GitHub. Make sure to provide detailed information about the issue or feature request, including steps to reproduce the bug if applicable.

We appreciate any code contributions that enhance the functionality or improve the user experience of OpSo. To contribute code, follow these steps:

1. Fork the repository to your GitHub account.
2. Clone your forked repository to your local machine.
3. Create a new branch for your feature or bug fix: git checkout -b feature-name.
4. Make your changes and ensure that the code follows the Flutter style guide.
5. Test your changes locally to ensure they work as expected.
6. Commit your changes with descriptive commit messages: git commit -m "Add feature XYZ".
7. Push your changes to your forked repository: git push origin feature-name.
8. Create a pull request against the main branch of the original repository.

To run the OpSo app locally, you need to have Flutter and Dart installed on your machine. Follow these steps:

1. Clone this repository:

git clone https://github.com/andoriyaprashant/OpSo.git

2. Navigate to the project’s root directory:

cd OpSo

3. Install dependencies:

flutter pub get

4. Check for Flutter setup and connected devices:

flutter doctor

5. Run the app:

flutter run

If you would like to add information about a new open-source program to OpSo, you can contribute by:

1. Gathering comprehensive information about the program, including its objectives, eligibility criteria, application process, and important dates.
2. Creating a new screen in the app to display information about the program.
3. Adding the program to the list of options in the home screen with relevant details.
4. Testing the new feature to ensure it works correctly.

Good documentation is essential for the success of any open-source project. If you notice any areas where the documentation can be improved, feel free to make updates or additions.

Please note that by contributing to OpSo, you agree to abide by the code of conduct. We expect all contributors to uphold the principles of respect, inclusivity, and collaboration.

Download source code on GitHub

The post OpSo – Open Source Programs App appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Learn

Welcome to **Learn**, a simple learning app built using Flutter for kids. This app is designed to provide an engaging learning experience for children, covering a wide range of topics including :

• A-Z Alphabets with examples and pronunciation.
• Animals and their pronunciation along with their voices.
• Body parts and their pronunciation with Short information on various topics.

More exciting features are planned for future updates, such as birds and their voices, information on the solar system, knowledge of shapes, and much more!

To get started with the Learn app, follow these simple steps :

git clone https://github.com/VaibhavCodeClub/learn

Please ensure you have Flutter installed. If not, you can follow the instructions on Flutter.dev to get it installed on your machine.

Navigate to the project directory using the terminal.

Run the following command to fetch the dependencies:

flutter pub get

Once the dependencies are fetched, run the app on your preferred device using :

flutter run

That’s it! The app should now be running on your device/emulator.

Note: If you encounter any issues or have suggestions for improvement, please feel free to create an issue on our GitHub repository. We appreciate your feedback!

Download this app source code on GitHub

The post Learning app for kids appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

API Dash is a beautiful open-source cross-platform API Client built using Flutter which can help you easily create & customize your API requests, visually inspect responses and generate API integration code. A lightweight alternative to postman/insomnia.

We are participating in GSoC 2024

API Dash is a beautiful open-source cross-platform API Client that can help you easily create & customize your API requests, visually inspect responses (full list of supported mime-types) and generate API integration code (full list) on the go.

API Dash can be downloaded from the links below:

 Create & Customize API Requests

• Create different types of HTTP requests (GET, HEAD, POST, PATCH, PUT and DELETE).
• Easily manipulate and play around with request inputs like headers, query parameters and body.
• Full support to send text content with Unicode/Emoji and preview any API response containing Unicode/Emoji.

Organize Requests in Collections & Folders

• Create collections and folders to organize your requests.
• Press and Drag to Re-arrange requests.
• Click and open popup menu to rename, duplicate and delete a request.

Visually Preview and Download Data & Multimedia API Responses

• Inspect the API Response (HTTP status code, error message, headers, body, time taken).
• View formatted code previews for responses of various content types like JSON, XML, YAML, HTML, SQL, etc.
• API Dash helps explore, test & preview Multimedia API responses which is not supported by any other API client. You can directly test APIs that return images, PDF, audio & more. Check out the full list of supported mimetypes/formats here.
• Save response body of any mimetype (image, text, etc.) directly in the Downloads folder of your system by clicking on the Download button.

Code Generation

• We started out as the only open source API client which supported advanced Dart code generation to easily integrate APIs in Dart/Flutter projects or to directly run it on DartPad. With time we have added more code-gens and currently API Dash supports generation of well-tested integration codes for JavaScript, Python, Kotlin & various other languages. You can check out the full list of supported languages/libraries.

Full Dark Mode Support

• Easily switch between light mode and dark mode.

Data

• Data is persisted locally on the disk. To save the current snapshot, just press the Save button in the collection pane.
• Click and open the collection/folder popup menu to export it as HAR. This can be version controlled & can be directly imported in other API Clients like Postman, Paw, etc.
• Export your entire data into a HAR (HTTP Archive) file. To access this option goto Settings > Export Data.

Settings & Other Options

• Customize various options using a dedicated Settings screen.
• Window Configuration (Size & Position) is persisted and restored on app start. (Only macOS & Windows)

API Dash currently supports API integration code generation for the following languages/libraries.

We welcome contributions to support other programming languages/libraries/frameworks. Please check out more details here.

API Dash is a next-gen API client that supports exploring, testing & previewing various data & multimedia API responses which is limited/not supported by other API clients. You can directly test APIs that return images, PDF, audio & more.

Here is the complete list of mimetypes that can be directly previewed in API Dash:

We welcome PRs to add support for previewing other multimedia mimetypes. Please go ahead and raise an issue so that we can discuss the approach. We are adding support for other mimetypes with each release. But, if you are looking for any particular mimetype support, please go ahead and open an issue. We will prioritize it’s addition.

Here is the complete list of mimetypes that are syntax highlighted in API Dash:

Visit CHANGELOG.md

Just click on the Issue tab to raise a new issue in this repo.

You can contribute to API Dash in any or all of the following ways:

• Ask a question
• Submit a bug report
• Request a new feature
• Choose from our existing list of ideas
• Suggest ways to improve the developer experience of an existing feature
• Add documentation
• To add a new feature, resolve an existing issue or add a new test to the project, check out our Contribution Guidelines.

Download this API Dash source code on GitHub

The post API Dash is a beautiful open-source cross-platform API Client appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Contributors should go through the Contributing Guide to learn how to raise an issue and send across a PR.

A curated list of useful Generative AI & LLM APIs for developers.

Generative AI APIs allow developers to integrate generative models into their applications without building the models from scratch. These APIs provide an interface for generating text, images, or other content. They also include LLM APIs that provide access to pre-trained language models for various tasks.

Some of the applications of these APIs are:

• Content Creation for blogs, social media, and marketing
• Virtual Assistants and Chatbots
• Language Translation Services to improve cross-language communication
• Provide tailored content based on user preferences in e-commerce, music, and video streaming
• Assist students and researchers in research & education
• ..and many more

The goal of this project is to create a Generative AI & LLM API hub for developers so that they can create innovative applications, enhance user experiences, and drive progress in the AI field.

You can start contributing by adding the following:

Download source code on GitHub

The post A curated list of useful Generative AI APIs for developers appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Device Calendar Plugin

A cross-platform plugin for modifying calendars on the user’s device.

• If you’re upgrading from previous versions, your code will need to be modified (slightly), otherwise it will not run after the update. See Timezone support for more details.
• There are some changes to event JSON formats at v4. Pay extra care if you handle event JSONs. Directly calling to and from the device calendars should be unaffected.

• Request permissions to modify calendars on the user’s device
• Check if permissions to modify the calendars on the user’s device have been granted
• Add or retrieve calendars on the user’s device
• Retrieve events associated with a calendar
• Add, update or delete events from a calendar
• Set up, edit or delete recurring events
  • NOTE: Editing a recurring event will currently edit all instances of it
  • NOTE: Deleting multiple instances in Android takes time to update, you’ll see the changes after a few seconds
• Add, modify or remove attendees and receive if an attendee is an organiser for an event
• Setup reminders for an event
• Specify a time zone for event start and end date
  • NOTE: Due to a limitation of iOS API, single time zone property is used for iOS (event.startTimeZone)
  • NOTE: For the time zone list, please refer to the TZ database name column on Wikipedia

Due to feedback we received, starting from 4.0.0 we will be using the timezone package to better handle all timezone data.

This is already included in this package. However, you need to add this line whenever the package is needed.

import 'package:timezone/timezone.dart';

If you don’t need any timezone specific features in your app, you may use flutter_native_timezone to get your devices’ current timezone, then convert your previous DateTime with it.

import 'package:flutter_native_timezone/flutter_native_timezone.dart';

initializeTimeZones();

// As an example, our default timezone is UTC.
Location _currentLocation = getLocation('Etc/UTC');

Future setCurentLocation() async {
  String timezone = 'Etc/UTC';
  try {
    timezone = await FlutterNativeTimezone.getLocalTimezone();
  } catch (e) {
    print('Could not get the local timezone');
  }
  _currentLocation = getLocation(timezone);
  setLocalLocation(_currentLocation);
}

...

event.start = TZDateTime.from(oldDateTime, _currentLocation);

For other use cases, feedback or future developments on the feature, feel free to open a discussion on GitHub.

From v3.9.0, device_calendar is null-safe. However, not all workflows have been checked and bugs from older versions still persist.

You are strongly advised to test your workflow with the new package before shipping. Better yet, please leave a note for what works and what doesn’t, or contribute some bug fixes!

The following will need to be added to the AndroidManifest.xml file for your application to indicate permissions to modify calendars are needed

<uses-permission android:name="android.permission.READ_CALENDAR" />
<uses-permission android:name="android.permission.WRITE_CALENDAR" />

NOTE: From v4.3.2 developers no longer need to add proguard rule in their app.

By default, all android apps go through R8 for file shrinking when building a release version. Currently, it interferes with some functions such as retrieveCalendars().

You may add the following setting to the ProGuard rules file proguard-rules.pro (thanks to Britannio Jarrett). Read more about the issue here

-keep class com.builttoroam.devicecalendar.** { *; }

See here for an example setup.

For more information, refer to the guide at Android Developer

Since v.1.0, this version has migrated to use AndroidX instead of the deprecated Android support libraries. When using 0.10.0 and onwards for this plugin, please ensure your application has been migrated following the guide here

For iOS 10+ support, you’ll need to modify the Info.plist to add the following key/value pair

<key>NSCalendarsUsageDescription</key>
<string>Access most functions for calendar viewing and editing.</string>

<key>NSContactsUsageDescription</key>
<string>Access contacts for event attendee editing.</string>

For iOS 17+ support, add the following key/value pair as well.

<key>NSCalendarsFullAccessUsageDescription</key>
<string>Access most functions for calendar viewing and editing.</string>

Note that on iOS, this is a Swift plugin. There is a known issue being tracked here by the Flutter team, where adding a plugin developed in Swift to an Objective-C project causes problems. If you run into such issues, please look at the suggested workarounds there.

Download source code on GitHub

The post A cross platform plugin for modifying calendars on the user’s device appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

FileSaver

This plugin package primarily focuses on one task: saving files on Android, iOS, Web, Windows, MacOS, and Linux. It might not have a plethora of features, but it does this job well. This package depends on path_provider for Android and iOS and basic html anchor for Web. The main reason I built this plugin was to avoid using HTML just for downloading files. The plugin is pretty simple and saves the file in Downloads folder in Windows, MacOS, Linux and directly downloads the file in Web, in iOS, the file is Saved in Application Documents Directory, and in Android it is saved in the applications files directory Android/data/your.package.name/file/your_file.extension.

The plugin itself is pretty easy to use. Just call the method saveFile() with respective arguments.

await FileSaver.instance.saveFile({
      required String name,
      Uint8List? bytes,
      File? file,
      String? filePath,
      LinkDetails? link,
      String ext = "",
      MimeType mimeType = MimeType.other,
      String? customMimeType,
      Dio? dioClient,
      Uint8List Function(Uint8List)? transformDioResponse,
      });

This saveFile() method has 8 Named arguments.

String name which takes the name of the file,
Uint8List bytes which will be your actual encoded file,
Or
File file which will be your file in the File object (from dart:io)
Or
Stirng filePath which will be your file path
Or
LinkDetails link which will provide the link, header, request method and body to your file. LinkDetails can be used as

LinkDetails(
      link: "https://www.example.com/file.extentions",
      headers: {"your-header-key": "you-header-value"},
      method: "POST",
      body: body
)

Out of these parameters, you will have to use atleast one

String ext this will be your file extension.
Another parameter is MimeType type Specifically for Web, which will be your file type

String customMimeType this will be your custom mime type, if you want to use your own mime type, you can use this parameter

Dio dioClient this will be your dio client, if you want to use dio for downloading the file, you can use this parameter

Uint8List Function(Uint8List) transformDioResponse this will be your function to transform the response, if you want to transform the response as per your requirement, you can use this parameter

MimeType is also included in my Package, I’ve included types for Sheets, Presentation, Word, Plain Text, PDF, MP3, MP4 and many other common formats

or you can call saveAs() only available for android and iOS & macOS at the moment

await FileSaver.instance.saveAs({
      required String name,
      Uint8List? bytes,
      File? file,
      String? filePath,
      LinkDetails? link,
      required String ext,
      required MimeType mimeType,
      String? customMimeType,
      Dio? dioClient,
      Uint8List Function(Uint8List)? transformDioResponse,
      });

All the parameters in this method are the same as the saveFile() method.

These Settings are optional for iOS, as in iOS the file will be saved in application documents directory but will not be visible in Files application, to make your file visible in iOS Files application, make the changes mentioned below.

Go to your project folder, ios/Runner/info.plist and Add these keys:

<key>LSSupportsOpeningDocumentsInPlace</key>
<true/>
<key>UIFileSharingEnabled</key>
<true/>

Open Your Project in XCode (Open XCode -> Open a project or file -> Your_Project_Folder/ios/Runner.xcworkspace) Open info.plist Add these rows:

Application supports iTunes file sharing (Boolean -> Yes)

Supports opening documents in place (Boolean -> Yes)

Go to your project folder, macOS/Runner/DebugProfile.entitlements

For release you need to open ‘YOUR_PROJECT_NAME’Profile.entitlements

and add the following key:

<key>com.apple.security.files.downloads.read-write</key>
<true/>

Open Your Project in XCode (Open XCode -> Open a project or file -> Your_Project_Folder/macos/Runner.xcworkspace) Open your entitlement file (DebugProfile.entitlements & ‘YOUR_PROJECT_NAME’Profile.entitlements)

Add these rows: 

and if you get Client Socket Exception while saving files in MacOS from link, you have to add this key in the DebugProfile.entitlements and Release.entitlements of your macOS application and set the value to true

<key>com.apple.security.network.client</key>
<true/>

You can find these files in the project_folder/macos/Runner/ directory.

Download source code on GitHub

The post A simple flutter plugin for saving files in all platforms appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

A new Flutter for TV project.

Getting Started

To run on AppleTV:

• Build a custom Flutter Engine for Apple TV or download already built from here (the last supported version is 3.16.9)
• Change FLUTTER_LOCAL_ENGINE value by the path to the custom engine in scripts/run_apple_tv.sh and in scripts/copy_framework.sh
• Run sh scripts/run_apple_tv.sh
• Press ‘Run’ in opened XCode (Xcode will be opened by script)

The article with details about Apple TV support

The details regarding the compilation of a custom engine you can find here.

Download source code on GitHub

The post A new Flutter for TV project appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

A Flutter package for rendering interactive 3D models in different formats(glb, gltf, fbx, obj), with ability to control animations, textures and camera.

Features

• Mobile and Web stable version (support glb & gltf format)
• Play animation
• Switch between animations
• Pause animation
• Reset animation
• Get available animations list
• Switch between textures
• Get available textures list
• Set camera target
• Reset camera target
• Set camera orbit
• Reset camera orbit

Samples

Compatibility

• Android
• iOS
• Web

Notes

• For now this package only support GLB & glTF format, other 3d formats coming soon.
• Visit the full example to see how to use this package

Brief Example

//Create controller object to control 3D model.
Flutter3DController controller = Flutter3DController();

//It will play 3D model animation, you can use it to play or switch between animations.
controller.playAnimation();

//If you pass specific animation name it will play that specific animation.
//If you pass null and your model has at least 1 animation it will play first animation.
controller.playAnimation(animationName: chosenAnimation);

//It will pause the animation at current frame.
controller.pauseAnimation();

//It will reset and play animation from first frame (from beginning).
controller.resetAnimation();

//It will return available animation list of 3D model.
await controller.getAvailableAnimations();

//It will load desired texture of 3D model, you need to pass texture name.
controller.setTexture(textureName: chosenTexture);

//It will return available textures list of 3D model.
await controller.getAvailableTextures();

//It will set your desired camera target.
controller.setCameraTarget(0.3, 0.2, 0.4);

//It will reset the camera target to default.
controller.resetCameraTarget();

//It will set your desired camera orbit.
controller.setCameraOrbit(20, 20, 5);

//It will reset the camera orbit to default.
controller.resetCameraOrbit();

//The 3D viewer widget
Flutter3DViewer(
  controller: controller,
  src: 'assets/business_man.glb',
)

Installation

pubspec.yaml

dependencies:
  flutter_3d_controller: ^1.2.1

AndroidManifest.xml (Android 9+ only)

To use this widget on Android 9+ devices, your app must be permitted to make an HTTP connection to http://localhost:XXXXX. Android 9 (API level 28) changed the default for [android:usesCleartextTraffic] from true to false, so you will need to configure your app’s android/app/src/main/AndroidManifest.xml as follows:

     <application
        android:name="${applicationName}"
        android:icon="@mipmap/ic_launcher"
-       android:label="example">
+       android:label="example"
+       android:usesCleartextTraffic="true">
        <activity
            android:name=".MainActivity"

This does not affect Android 8 and earlier. See [#7] for more information.

app/build.gradle (Android only)

Change minSdkVersion to 21.

defaultConfig {
    ...
    minSdkVersion 21
    ...
}

Info.plist (iOS only)

To use this widget on iOS, you need to opt-in to the embedded views preview by adding a boolean property to your app’s ios/Runner/Info.plist file, with the key io.flutter.embedded_views_preview and the value YES:

  <key>io.flutter.embedded_views_preview</key>
  <true/>

web/index.html (Web only)

Modify the <head> tag of your web/index.html to load the JavaScript, like so:

<head>

  <!-- Other stuff -->

  <script type="module" src="./assets/packages/flutter_3d_controller/assets/model-viewer.min.js" defer></script>
</head>

More Info

This package uses ‘Model Viewer’ to render 3D models and it may have some issues in rendering some models/textures, the core of the package (Model Viewer) will change in the future to support all types of 3D models

Download and/or contribute to this package source code on GitHub

The post A Flutter package for rendering interactive 3D models appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Determining the MIME type for a file

The MimeTypeResolver class can be used to determine the MIME type of a file. It supports both using the extension of the file name and looking at magic bytes from the beginning of the file.

There is a builtin instance of MimeTypeResolver accessible through the top level function lookupMimeType. This builtin instance has the most common file name extensions and magic bytes registered.

import 'package:mime/mime.dart';

void main() {
  print(lookupMimeType('test.html'));
  // text/html

  print(lookupMimeType('test', headerBytes: [0xFF, 0xD8]));
  // image/jpeg

  print(lookupMimeType('test.html', headerBytes: [0xFF, 0xD8]));
  // image/jpeg
}

You can build you own resolver by creating an instance of MimeTypeResolver and adding file name extensions and magic bytes using addExtension and addMagicNumber.

Processing MIME multipart media types

The class MimeMultipartTransformer is used to process a Stream of bytes encoded using a MIME multipart media types encoding. The transformer provides a new Stream of MimeMultipart objects each of which have the headers and the content of each part. The content of a part is provided as a stream of bytes.

Below is an example showing how to process an HTTP request and print the length of the content of each part.

// HTTP request with content type multipart/form-data.
HttpRequest request = ...;
// Determine the boundary form the content type header
String boundary = request.headers.contentType.parameters['boundary'];

// Process the body just calculating the length of each part.
request
    .transform(new MimeMultipartTransformer(boundary))
    .map((part) => part.fold(0, (p, d) => p + d))
    .listen((length) => print('Part with length $length'));

The post Dart package for working with MIME type definitions appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Experiments with upcoming Dart macros

Setup

• Update your SDK to a dev build (this was written on 3.4.0-77.0.dev)
• For Flutter users: flutter channel master
• Add --enable-experiment=macros to dart invocations
• In VS Code update to the Pre-Release Dart/Flutter extensions

@Model()

This is a replacement for the freezed and json_serializable packages.

It implements fromJson, toJson, copyWith, toString, operator == and hashCode.

See bin/model.dart for an example.

See lib/model.dart for implementation.

Disclaimer

I’ve definitely missed edge cases. Create an issue or a pull request. Do not use it in production yet.

Download and/or contribute to this package on GitHub

The post Experiments with upcoming Dart macros appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

The Google Generative AI SDK for Dart allows developers to use state-of-the-art Large Language Models (LLMs) to build language applications.

Getting Started

This repository contains a few sample apps. To try them out, follow these steps:

• Change the directory to the samples package.
• Export a $GOOGLE_API_KEY environment variable with an API key with access to the Gemini generative models, or run the below commands with an environment containing this variable.
• Run any sample from the bin directory (e.g., dart bin/simple_text.dart).

Using the SDK in your own app

Add a dependency on this repository to the path pkgs/google_generative_ai. Once the API is stable the package will be available from pub. We welcome pre-publish feedback through GitHub issues.

dependencies:
  google_generative_ai:
    git:
      url: [email protected]:google/generative-ai-dart.git
      path: pkgs/google_generative_ai
      ref: main

Initializing the API client

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);

Calling the API

final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = await model.generateContent(content);
print(response.text);

Documentation

Find complete documentation for the Google AI SDKs and the Gemini model in the Google documentation: https://ai.google.dev/docs

Packages

Contributing

See Contributing for more information on contributing to the Generative AI SDK for Dart.

License

The contents of this repository are licensed under the Apache License, version 2.0.

Contribute and/or download to this SDK source code on GitHub

The post Google AI SDK for Dart appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Description

flutter_gemini_bot is a package that allows you to easily create a chatbot application in Flutter. It is built on top of the Gemini API.

 

Table of Contents

• Features
• Getting Started
• Usage
• Contributing
• License

Features

This package provides a FlutterGeminiChat widget that you can use to create a chat bot interface in your Flutter application.

Getting Started

To use this package, you will need:

• A list of ChatModel objects representing the chat messages or sessions
• An API key for authenticating with the chatbot service To use the Gemini API, you’ll need an API key. If you don’t already have one, create a key in Google AI Studio. Get an API key.

Usage

Here is an example of how to use the FlutterGeminiChat widget:

Get the package

flutter pub add flutter_gemini_bot

Use the package

List<ChatModel> chatList = []; // Your list of ChatModel objects
String apiKey = 'your_api_key'; // Your API key

FlutterGeminiChat(
  chatContext: 'example_context',
  chatList: chatList,

  apiKey: apiKey,
),

Contributing

This project is open source and we welcome contributions. Please feel free to submit a pull request or open an issue.

License

This project is licensed under the MIT License.

Download source code on GitHub

The post Create A Customizable Chatbot Easily And Quickly With Flutter appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Craft beautiful, accessible, and responsive Flutter UIs with a Modular-UI Design-inspired component library

Get involved: join our discord :)))

See our card creation guide

Here are some of the examples :

Current Status of Components/Widgets (might be on the development branch)

•  Accordion
•  Alert Boxes
•  Avatar
•  Breadcrumbs
•  Button
  •  Primary Button
  •  Secondary Button
  •  Loading Button
  •  Gradient Button
  •  Outlined Button
  •  Secondary Outlined Button
  •  Text Button
  •  Primary Block Level Button
  •  Secondary Block Level Button
  •  Gradient Block Level Button
  •  Loading Block Level Button
  •  Outlined Block Level Button
  •  Secondary Outlined Block Level Button
  •  Text Block Level Button
  •  Auth Buttons
•  Card
  •  Simple Card
  •  Card With Image
  •  Primary Card
  •  Profile Card
  •  Sign in Card
  •  Sign up Card
  •  Pricing Card
  •  Blog Card
  •  Blog Card With Background
  •  Booking Card
  •  Testimonial Card
  •  E-commerce Card
•  Checkbox
•  Chip
•  Collapse
•  Carousel
•  Dialog
•  Drawer
•  Footer
•  Form
•  Input Fields
  •  Primary Input Field
  •  Input With Icon
  •  Input With Button
•  List Tile
•  Navbar
•  Popover
•  Progress Bar
•  Radio Button
•  Rating Bar
•  Select
•  Slider
•  Tab View
•  Switch

Goals

•  Ship ModularUI to Pub
•  Landing Page
• A Flutter web app to test every widget.
•  CLI tool.

Calling on all the trendsetting Flutter enthusiasts! Join forces as we pioneer the creation of the ultimate, expansive, and seamless UI Library for Flutter. Let’s make waves together!

Setting Up Locally :

1. Run flutter create . inside the project folder to generate any necessary files
2. Go inside project root and run flutter packages pub global activate --source path . and export the PATH if necessary or add the path as an Environment Variable.
3. Now you can import the local version of modular_ui and test it during your development

dependencies:
  modular_ui:
    path: <replace_with_cloned_repo_location>

4. import 'package:modular_ui/modular_ui.dart'; in your other flutter project.

Design Language :

ModularUI Design language is inspired by Material Tailwind and shadcn/ui Our current goal is to make as many components as possible and ship this asap, so we might merge any widget that looks like them or if they are consistent with our theme, obviously the future goal would be to make them perfect and consistent.

Widget Naming Convention :

any widget of ModularUI must follow this naming convention : MUI<widget_name> e.g. MUIPrimaryButton MUI stands for ModularUI.

Features

• Comprehensive Modular-UI Design Components: Build modern and feature-rich interfaces with a wide range of buttons, cards, forms, navigation elements, and more.
• Highly customizable: Tailor components to your exact needs with extensive styling options.
• Responsive design: Ensure optimal UI experiences across different screen sizes.
• Accessibility focus: Built with accessibility in mind, adhering to best practices.
• Lightweight and performant: Efficiently crafted for smooth user interactions.

Additional Features

• Custom themes and color palettes: Define your own visual style for a cohesive look.
• Dark mode support: Seamlessly adapt your UI to user preferences.

Documentation

• Comprehensive API documentation with examples and usage guidelines.
• Live demos and tutorials showcasing component usage and best practices.
• UNDER DEVELOPMENT

Contributing

We welcome contributions! Please refer to our contribution guidelines for details.

License

This project is licensed under the BSD-3.

Series of events: How we began

While casually scrolling through Twitter, I stumbled upon an intriguing tweet from Luke that sparked a burst of inspiration within me. Fueling my curiosity, I conducted a Poll on Luke’s original post, and to my delight, several individuals expressed interest. Emboldened by this positive response, I decided to take the plunge.

Enter Yash, a kindred spirit who shared my enthusiasm. Together, we embraced the challenge with rocket-like enthusiasm .

Sharing our endeavor on Twitter garnered an impressive reception, surpassing even my own expectations. Tweet link

And now, the moment has arrived—our modular_ui repository is officially public! We’re optimistic that it will find a welcoming home among Flutter developers, paving the way for a custom UI library tailored for the Flutter community.

Download source code on GitHub

The post ModularUI : Pre-built beautiful flutter widgets appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Download from one of the above app stores to receive auto-updates. Manual installs can be found here.

About

PathPlanner is a motion profile generator for FRC robots created by team 3015. The main features of PathPlanner include:

• Each path is made with Bézier curves, allowing fine tuning of the exact path shape.
• Holonomic mode supports decoupling the robot’s rotation from its direction of travel.
• Real-time path preview
• Allows placing “event markers” along the path which can be used to trigger other code while path following.
• Build modular autonomous routines using other paths.
• Automatic saving and file management
• Robot-side vendor library for path generation and custom path following commands/controllers
• Full autonomous command generation with PathPlannerLib auto builder
• Real time path following telemetry
• Hot reload (paths and autos can be updated and regenerated on the robot without redeploying code)
• Automatic pathfinding in PathPlannerLib with AD*

Usage and Documentation

pathplanner.dev

Make sure you install PathPlannerLib to generate your paths.

https://3015rangerrobotics.github.io/pathplannerlib/PathplannerLib.json

Java API Docs

C++ API Docs

Python API Docs

How to build manually:

• Install Flutter
• Open the project in a terminal and run the following command: flutter build <PLATFORM>
  • Valid platforms are:
    • windows
    • macos
    • linux
• The built app will be located here:
  • Windows: <PROJECT DIR>/build/windows/runner/Release
  • macOS: <PROJECT DIR>/build/macos/Build/Products/Release
  • Linux: <PROJECT DIR>/build/linux/x64/release/bundle
• OR flutter run to run in debug mode

Download source code on GitHub

The post A simple yet powerful path planning tool for FRC robots appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Movie Hub is an app that allows users to view different categories of movies and also watch!. It creates an immersive and seamless movie-watching experience!. It is built with Flutter and Firebase using the TMDB API and VidSrc for viewing the movies.

It provides an interactive and captivating experience for the user!

Demo

Preview

Key Features

• View movies in diverse categories (e.g Trending, Popular, Upcoming, Top Rated)
• Discover Movies
• Watch movies
• Add Movies to watchList
• Search for Movies
• Sign in, Sign Up, Forgot Password, Sign Out
• Choose Avatar
• View Similar Movies to a Movie
• View Images from a Movie
• Infinite scrolling with pagination
• Nice Loading UI with the Shimmer
• Visit Movie’s webpage

Installation

• You can download the apk to your Android device from here

To run MovieHub from the Codebase, you need to get a TMDB API key from here you will have to create an account, if you don’t have one.

Once you have the API Key, you can create an api_keys.dart file, locate the lib > core > utils and create the file under it

Add the following:

String get baseUrl => 'https://api.themoviedb.org/3';

String get apiKey => 'YOUR API KEY';

String get videoBaseUrl => 'https://vidsrc.to/embed/movie/';

You also need to create a firebase project at Firebase

With all these in place, you can

flutter run

Packages Used

• flutter_screenutil: For making the sizes used in the app are responsive
• flutter_svg: For loading SVG assets
• cached_network_image: For caching data of images to boost app performance
• provider: For managing state across the app
• get_it: For dependency Injection
• equatable: To enable comparison of objects
• http: To enable network calls
• shimmer: For the beautiful loader
• carousel_slider: For the Trending Movie Preview
• intl: For advanced date Formatting
• url_launcher: To open web pages
• flutter_inappwebview: For launching the movie screen
• lottie: For the nice animated assets used for empty, error and loading states
• fpdart: For Functional Programming mainly for the use of Either.
• firebase_core, firebase_auth, firebase_storage, cloud_firestore, firebase_crashlytics: which are Firebase services!

Lessons Learned and Challenges faced

Veni, Vidi, Vici!

I faced a lot of issues during the development of this app, but i also learnt alot!

• The main reason why i took on this task is to explore Firebase well, and i did that to an extent, exploring its Database, Storage, Crashlytics and Authentication Services.
• I had issues trying to make watching movies possible, then when i thought i had gotten it right, it wasn’t working on Android , but i had to do more research and changed the webview package , after a lot of iteration, it worked!
• I also had issues while implementing the watchlist section, i had a bug that took me a while to fix, but after speaking to my seniors and alot of reflection, i got it right
• What kept me going was the joy i felt after i completed a feature successfully.

The post Movie Hub appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Cliptopia

Cliptopia is a state-of-the-art clipboard management software for the Linux desktops that turns your simple clipboard into a full-fledged power house

Cliptopia watches not only your texts but also any emojis, colors, commands, web images, screenshots or any local file/directory that you copy and then, it provides a full-fledged powerful interface supporting advanced searching and filtering which even allows you to search any image that you have copied. This is just the tip of the features Cliptopia provides out of the box.

As the names goes Cliptopia, it is all about your clipboard, but in the sense of vast land which is full of features that provides you a clipboard experience in the best ever form out there.

Features

• Cliptopia supports commenting on clipboard items
• Clipboard Content Protection Mechanism
• Handy set of shortcuts to toggle sensitive data
• Regex mode content filtering
• Go Incognito with just a click of a toggle
• An intelligent cache management system
• File extension mode searching
• Protecting your clipboard contents from being accidentally displayed during screen sharing
• Filtering Items by Date
• Finding Items by comments
• Filtering Images on the basis of aspect ratios
• Displaying images from copied files
• Compositor independent content injection
  (even if your desktop environment doesn’t supports **virtual-keyboard-protocol **cliptopia never fails to work )
• Built-in App Bug Report Generation
•  Built-in issues identification panel
• Command execution right from the User Interface
• Fully Compositor Independent (No matter if it is X11 or Wayland, Cliptopia rocks)
• And a very attractive custom User Interface

See The Daemon , to explore more features.

GNOME (Ubuntu)

This is for users who are running GNOME on Ubuntu in a wayland session (default session). Rather than using wl-clipboard, please enable force-xclip mode from cliptopia’s settings to prevent encounter this issue.

 The Daemon

At the heart of Cliptopia lies the cliptopia-daemon which is responsible for watching your clipboard.

When you install Cliptopia, you can run it directly from the app launcher or by just executing cliptopia in your terminal or by pressing Super + V after you have created the clipboard shortcut. In any case, cliptopia will ask you to install the daemon …

Either you can download/build it from source by yourself from its repo or you let Cliptopia handle this for you. Yes, Cliptopia can itself download the daemon for you if you desire so.

Moving further, in any case, the daemon should be placed at /usr/bin so that cliptopia can manage it.

Cliptopia is compositor independent which means it works the same no matter you are on X11 or Wayland. On X11, xclip is used to watch the clipboard and on Wayland wl-clipboard is used.

On some distros, like Ubuntu with GNOME on Wayland, xclip still works because of an XWayland session, so, if you want you can force cliptopia to use xclip even on wayland also from its settings panel.

Please note that Cliptopia is in beta until a stable version released, which is expected to be released by the end of this month.

Installation

Right now, you can install cliptopia from the source or from .deb package in the releases section.

Before that you need the following commands available in your linux distribution …

• grep
• java 17 or above
• xclip
• pgrep
• pkexec
• whereis
• wl-clipboard (for wayland only)
• and optionally flutter 3.16 or above if you are installing from source.

Yes, Cliptopia is written entirely using Flutter, thus, it compiles to native and delivers lightening fast performance as your other apps.

Installing Cliptopia is a very easy and fast process …

• Just Clone the official repo

git clone https://github.com/omegaui/cliptopia

• move into the cloned repo

cd cliptopia

• and run the install-from-source.sh script to install from source

./install-from-source.sh

Running the above commands in sequence will install cliptopia on your machine.

If you have already installed cliptopia, running the above commands will result in manually updating your installation.

Keyboard Shortcut

Then, you need to add a custom keyboard shortcut to invoke Cliptopia in Power Mode … 

If you have installed Cliptopia from releases using the .deb package, then, change

cliptopia --silent --power

to

/usr/local/lib/Cliptopia/cliptopia --silent --power

Modes

Cliptopia can be made to launch in three mode:

• Normal Mode (cliptopia)
• Silent Mode (cliptopia --silent)
• Power Mode (cliptopia --silent --power)

Injection: it refers to clicking on an clipboard element in the UI of Cliptopia to insert it in the last focussed field.

Normal Mode

• Updates in real time as you use your clipboard
• Supports content injection
• Does not quits after injection is performed

Silent Mode

• Updates in real time as you use your clipboard
• Supports content injection
• Quits after injection is performed

Power Mode

• Does NOT updates in real time as you use your clipboard
• Supports content injection
• Quits after injection is performed

There is a very valid reason Power Mode is designed to not update in real time, as we know, Super + V combination can be used to bring the Power Mode into effect, it is designed to be used occasionally when you require to find an item that you copied earlier and in cases, where you need to do this quickly.

So, for the Power Mode to get ready in an instant, a single read of the cache is performed to deliver the fastest possible performance on your system, thus, preventing the real time updates as there is no watching of the cache being maintained by the daemon.

That’s why power mode does not update in realtime.

But, We do not stop here, actually the Power Mode can be made to update in real time, by using the --update flag. Work on this is currently under development.

Updates

Cliptopia will have a built-in update system, so, when a new release arrives, your installation will automatically notify you about it.

Uninstallation

Cliptopia will even offer an in-app uninstall feature to uninstall cliptopia from your system in case you want a fresh install.

Screenshot Gallery

Download source code on GitHub

The post Cliptopia is a state-of-the-art clipboard management software for the linux desktops appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Web and desktop are not supported.

Contributions welcome!

Supported API

Feature	Android	iOS
Style
Camera position
Camera animations
Events
Gestures
User Location
Circle Layer
Fill Layer
Fill extrusion Layer
Line Layer
Circle Layer
Raster Layer
Symbol Layer
Hillshade Layer
Heatmap Layer
Sky Layer
GeoJson Source
Image Source
Vector Source
Raster Source
Rasterdem Source
Circle Annotations
Point Annotations
Line Annotations
Fill Annotations
Offline
Viewport
Style DSL
Expression DSL
View Annotations

Requirements

The Maps Flutter Plugin is compatible with applications:

• Deployed on iOS 11 or higher
• Built using the Android SDK 21 or higher
• Built using the Dart SDK 2.17.1 or higher

Installation

Configure credentials

To run the Maps Flutter Plugin you will need to configure the Mapbox Access Tokens. Read more about access tokens and public/secret scopes at the platform Android or iOS docs.

Secret token

To access platform SDKs you will need to create a secret access token with the Downloads:Read scope and then:

• to download the Android SDK add the token configuration to ~/.gradle/gradle.properties :

  SDK_REGISTRY_TOKEN=YOUR_SECRET_MAPBOX_ACCESS_TOKEN

• to download the iOS SDK add the token configuration to ~/.netrc :

  machine api.mapbox.com
  login mapbox
  password YOUR_SECRET_MAPBOX_ACCESS_TOKEN

Public token

To instantiate the MapWidget widget pass the public access token with ResourceOptions:

  MapWidget(
    resourceOptions:
        ResourceOptions(accessToken: PUBLIC_ACCESS_TOKEN))));

It’s a good practice to retrieve access tokens from some external source.

You can pass access token via the command line arguments when either building :

flutter build <platform> --dart-define PUBLIC_ACCESS_TOKEN=...

or running the application :

flutter run --dart-define PUBLIC_ACCESS_TOKEN=...

You can also persist token in launch.json :

"configurations": [
    {
        ...
        "args": [
            "--dart-define", "PUBLIC_ACCESS_TOKEN=..."
        ],
    }
]

Then to retrieve the token from the environment in the application :

String ACCESS_TOKEN = String.fromEnvironment("PUBLIC_ACCESS_TOKEN");

Add the dependency

To use the Maps Flutter Plugin add the git dependency to the pubspec.yaml:

dependencies:
  mapbox_maps_flutter: ^0.5.1

Configure permissions

You will need to grant location permission in order to use the location component of the Maps Flutter Plugin.

You can use an existing library to request location permission, e.g. with permission_handler await Permission.locationWhenInUse.request(); will trigger permission request.

You also need to declare the permission for both platforms :

Android

Add the following permissions to the manifest:

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

iOS

Add the following to the Runner/Info.plist to explain why you need access to the location data:

    <key>NSLocationWhenInUseUsageDescription</key>
    <string>[Your explanation here]</string>

Add a map

Import mapbox_maps_flutter library and add a simple map:

import 'package:flutter/material.dart';
import 'package:mapbox_maps_flutter/mapbox_maps_flutter.dart';

void main() {
  runApp(MaterialApp(
      home: MapWidget(
          resourceOptions: ResourceOptions(accessToken: YOUR_ACCESS_TOKEN))));
}

MapWidget widget

The MapWidget widget provides options to customize the map – you can set ResourceOptions, MapOptions, CameraOptions, styleURL.

It also allows or add listeners for various events – related to style loading, map rendering, map loading.

MapboxMap controller

The MapboxMap controller instance is provided with MapWidget.onMapCreated callback.

MapboxMap exposes an entry point to the most of the APIs Maps Flutter Plugin provides. It allows to control the map, camera, styles, observe map events, query rendered features, etc.

It’s organized similarly to the Android and iOS counterparts.

To interact with the map after it’s created store the MapboxMap object somewhere :

class FullMap extends StatefulWidget {
  const FullMap();

  @override
  State createState() => FullMapState();
}

class FullMapState extends State<FullMap> {
  MapboxMap? mapboxMap;

  _onMapCreated(MapboxMap mapboxMap) {
    this.mapboxMap = mapboxMap;
  }

  @override
  Widget build(BuildContext context) {
    return new Scaffold(
        body: MapWidget(
      key: ValueKey("mapWidget"),
      resourceOptions: ResourceOptions(accessToken: ACCESS_TOKEN),
      onMapCreated: _onMapCreated,
    ));
  }
}

User location

Platform docs : Android, iOS.

To observe the user’s location and show the location indicator on the map use LocationComponentSettingsInterface accessible via MapboxMap.location.

You need to grant location permission prior to using location component (as explained before).

Location puck

To customize the appearance of the location puck call MapboxMap.location.updateSettings method.

To use the 3D puck with model downloaded from Uri instead of the default 2D puck :

  mapboxMap.location.updateSettings(LocationComponentSettings(
      locationPuck: LocationPuck(
          locationPuck3D: LocationPuck3D(
              modelUri:
                  "https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master/2.0/Duck/glTF-Embedded/Duck.gltf",))));

You can find more examples of customization in the sample app.

Markers and annotations

Platform docs : Android, iOS.

You have several options to add annotations on the map.

1. Use the AnnotationManager APIs to create circle/point/polygon/polyline annotations.

To create 5 point annotations using custom icon:

  mapboxMap.annotations.createPointAnnotationManager().then((pointAnnotationManager) async {
    final ByteData bytes =
        await rootBundle.load('assets/symbols/custom-icon.png');
    final Uint8List list = bytes.buffer.asUint8List();
    var options = <PointAnnotationOptions>[];
    for (var i = 0; i < 5; i++) {
      options.add(PointAnnotationOptions(
          geometry: createRandomPoint().toJson(), image: list));
    }
    pointAnnotationManager?.createMulti(options);
  });

You can find more examples of the AnnotationManagers usage in the sample app : point annotations, circle annotations, polygon annotations, polyline annotations.

1. Use style layers. This will require writing more code but is more flexible and provides better performance for the large amount of annotations (e.g. hundreds and thousands of them). More about adding style layers in the Map styles section.

Map styles

Platform docs : Android, iOS.

The Mapbox Maps Flutter Plugin allows full customization of the look of the map used in your application.

Set a style

You can specify the initial style uri at MapWidget.styleUri, or load it at runtime using MapboxMap.loadStyleURI / MapboxMap.loadStyleJson :

  mapboxMap.loadStyleURI(Styles.LIGHT);

Work with layers

You can familiarize with the concept of sources, layers and their supported types in the platform documentation.

To add, remove or change a source or a layer use the MapboxMap.style object.

To add a GeoJsonSource and a LineLayer using the source :

  var data = await rootBundle.loadString('assets/polyline.geojson');
  await mapboxMap.style.addSource(GeoJsonSource(id: "line", data: data));
  await mapboxMap.style.addLayer(LineLayer(
      id: "line_layer",
      sourceId: "line",
      lineJoin: LineJoin.ROUND,
      lineCap: LineCap.ROUND,
      lineOpacity: 0.7,
      lineColor: Colors.red.value,
      lineWidth: 8.0));

Using expressions

You can change the appearance of a layer based on properties in the layer’s data source or zoom level. Refer to the documentation for the description of supported expressions. To apply an expression to interpolate gradient color to a line layer:

  mapboxMap.style.setStyleLayerProperty("layer", "line-gradient",
      '["interpolate",["linear"],["line-progress"],0.0,["rgb",6,1,255],0.5,["rgb",0,255,42],0.7,["rgb",255,252,0],1.0,["rgb",255,30,0]]');

Camera and animations

Platform docs : Android, iOS. The camera is the user’s viewpoint above the map. The Maps Flutter Plugin provides you with options to set and adjust the camera position, listen for camera changes, get the camera position, and restrict the camera position to set bounds.

Camera position

You can set the starting camera position using MapWidget.cameraOptions :

MapWidget(
  key: ValueKey("mapWidget"),
  resourceOptions: ResourceOptions(accessToken: ACCESS_TOKEN),
  cameraOptions: CameraOptions(
      center: Point(coordinates: Position(-80.1263, 25.7845)).toJson(),
      zoom: 12.0),
));

or update it at runtime using MapboxMap.setCamera :

MapboxMap.setCamera(CameraOptions(
  center: Point(coordinates: Position(-80.1263, 25.7845)).toJson(),
  zoom: 12.0));

You can find more examples of interaction with the camera in the sample app.

Camera animations

Camera animations are the means by which camera settings are changed from old values to new values over a period of time. You can animate the camera using flyTo or easeTo and move to a new center location, update the bearing, pitch, zoom, padding, and anchor.

To start a flyTo animation to the specific camera options :

  mapboxMap?.flyTo(
    CameraOptions(
        anchor: ScreenCoordinate(x: 0, y: 0),
        zoom: 17,
        bearing: 180,
        pitch: 30),
    MapAnimationOptions(duration: 2000, startDelay: 0));

You can find more examples of animations in the sample app.

User interaction

Platform docs : Android, iOS.

Users interacting with the map in your application can explore the map by performing standard gestures.

You can retrieve or update the GestureSettings using MapboxMap.gestures.

You can observe gesture events using MapWidget.onTapListener, MapWidget.onLongTapListener, MapWidget.onScrollListener.

Download source code on GitHub

The post Mapbox Maps SDK Flutter Plugin appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

LaLa Trainers Launcher

A free and cross-platform trainers launcher for enhancing your gaming experience.

Thank You, Gaming Community

After posting Reddit threads introducing LaLa, I received valuable feedback and input from many gamers. I want to express my gratitude to all of you.
Below is a list of to-do items based on the feedback I’ve received:

• Work on making the launcher compatible with non-Steam games.
• Improve warnings and safeguards for multiplayer games.

Screenshots

  

Supported platforms

• Windows
• Linux
• Steam Deck
• macOS (coming soon)

Installation

You can download prebuilt binaries directly from GitHub releases or BiliBili

• For Windows user, install exe file directly.
• For Linux user, run following commands to install.

  sudo dpkg -i LaLa_linux_amd64.deb
  or
  sudo apt install ./LaLa_linux_amd64.deb
  or
  flatpak install --user LaLa_linux_amd64.flatpak
  or
  run LaLa_linux_amd64.AppImage directly🥰
• For Steam Deck User, run following commands to install.

  flatpak install --user LaLa_linux_amd64.flatpak
  or
  run LaLa_linux_amd64.AppImage directly🥰

 Important notice for Linux user

The LaLa Launcher for Linux relies on Proton to run trainers. To use trainers, you must:

• Install Steam and set up Proton.
• Have the game already installed.

FAQ

During installation, my operating system warns about security.

LaLa Trainers Launcher is an open-source software developed using Flutter. Any security warning you encounter during installation is a false positive from your system. You can safely proceed with the installation.

Is the trainers downloaded by LaLa Trainers Launcher safe?

Most of the trainers used by LaLa Trainers Launcher are sourced from Fling Trainers, and a few are from open-source cheat tables that I’ve collected.
While every effort is made to ensure their safety, please use them responsibly, and be aware that the use of trainers can carry risks.

Where is LaLa Trainers Launcher’s cache data stored?

On Windows, the cache data is located in the %LOCALAPPDATA%/com.aironheart.lala directory.
On Linux, it can be found in either $XDG_CACHE_HOME/com.aironheart.lala or ~/.cache/com.aironheart.lala.

Why is it named LaLa Trainers Launcher?

It’s named after my love for the movie “La La Land”. I hope you can enjoy using the software.

Support

LaLa Trainers Launcher is an open-source project that runs on donations.

Download source code on GitHub

The post LaLa Trainers Launcher appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Nylo

Nylo is a micro-framework for Flutter that is designed to help simplify developing apps. Every project provides a simple boilerplate and MVC pattern to help you build apps more easily.

This project is open-source and MIT-licenced, we welcome any contributions. You can join as a backer/sponsor to fund future development for this project here

Features

Some core features available

• Routing.
• Themes and styling.
• Localization.
• CLI for generating project files.
• Elegant API Services for Networking.
• Creating App Icons.
• Project Configuration.
• Streamlined Project Structure.

Requirements

• Dart >= 3.1.3

Getting Started

git clone https://github.com/nylo-core/nylo.git

Documentation

View our docs and visit nylo.dev

Changelog

Please see CHANGELOG for more information on what has changed recently.

Security

If you discover any security related issues, please email [email protected] instead of using the issue tracker.

Download source code on GitHub

The post Nylo project for Flutter developers appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

What’s Inside

1. Common Blur Effects

A collection of common blur effects, serving as a practical guide for integration into your projects.

2. Interactive Blur Explainer

A hands-on app to visually grasp how blur effects transform pictures.

3. iOS 17 Name Drop Animation

A best effort replicate(sort of) the captivating name drop animation seen in iOS 17. it needs more work to look close to the real one which is not open source (obviously).

4. iOS 17 Faded Gradient

iOS 17’s elegant faded gradient effect. by using one of the common blur effects and changing it a bit.

Stay Updated

I have few more upcoming demos to show (I didn’t get the time to finish them before the meetup)! Star and watch the repo to keep up with the latest demos and updates.

Download source code on GitHub

The post Explore Blur Effect appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Welcome to Calentre, the open-source alternative to Calendly! Manage your appointments, get paid, and enjoy the scheduling experience.

Table of Contents

• Description
• Features
• Technology Stack
• Architecture
• Getting Started
• Usage

Description

Calentre is your go-to scheduling solution, offering a delightful way to book meetings and collect payments! Whether you’re a consultant, freelancer, or professional, we’ve got you covered.

Features

• Scheduling: Let clients book appointments with ease.
• Payment Integration: Seamlessly get paid for your valuable time.
• Customization: Tailor the scheduling process to match your style.
• Notifications: Stay in the loop with automated email updates.
• User-Friendly Interface: Smooth and friendly for all users.

Technology Stack

Calentre’s magic is built using:

• Flutter: The admin scheduler is built with Flutter. Primarily serving Flutter Web.
• Supabase: All backend-related functions are handled by Supabase
• ReactJs + NextJs: The front-facing client scheduler is built into react

Architecture

Calentre embraces the Clean Architecture principles, keeping things neat and organized. Enjoy a clean and maintainable codebase! For details, see our Architecture Guide

Getting Started

Ready to dive in? Let’s go:

1. Clone the repository: git clone https://github.com/fiizzy/calentre.git
2. Move to the project: cd calentre
3. Grab dependencies: flutter pub get
4. Set up your Supabase instance and update app configuration.
5. Start the app: flutter run

For details, see our Getting Started Guide.

Usage

Using Calentre is a breeze:

1. Sign in or create an account.
2. Adjust your availability and preferences.
3. Share your scheduling link with clients.
4. Clients book appointments and pay seamlessly.
5. Get notifications and revel in your organized life.

For more, check the User Guide.

Download source code on GitHub

The post A simple app that allows you create events appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Table of Contents

• Overview
• Installation
• Contributing
• Documentation
• Supported Environments
• Acknowledgments
• License

Overview

Firebase provides the tools and infrastructure you need to develop your app, grow your user base, and earn money. The Firebase Admin Node.js SDK enables access to Firebase services from privileged environments (such as servers or cloud) in Node.js.

For more information, visit the Firebase Admin SDK setup guide.

Installation

The Firebase Admin Node.js SDK is available on npm as firebase-admin:

$ npm install --save firebase-admin

To use the module in your application, require it from any JavaScript file:

const { initializeApp } = require("firebase-admin/app");

initializeApp();

If you are using ES2015, you can import the module instead:

import { initializeApp } from "firebase-admin/app";

initializeApp();

Contributing

Please refer to the CONTRIBUTING page for more information about how you can contribute to this project. We welcome bug reports, feature requests, code review feedback, and also pull requests.

Supported Environments

We support Node.js 14 and higher.

Please also note that the Admin SDK should only be used in server-side/back-end environments controlled by the app developer. This includes most server and serverless platforms (both on-premise and in the cloud). It is not recommended to use the Admin SDK in client-side environments.

Documentation

• Setup Guide
• Database Guide
• Authentication Guide
• Cloud Messaging Guide
• API Reference
• Release Notes

Acknowledgments

Thanks to the team at Casetext for transferring ownership of the firebase-admin npm module over to the Firebase team and for their longtime use and support of the Firebase platform.

License

Firebase Admin Node.js SDK is licensed under the Apache License, version 2.0.

Your use of Firebase is governed by the Terms of Service for Firebase Services.

Download and/or contribute to this SDK source code on GitHub

The post Firebase Admin Node.js SDK appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Welcome! This project is a port of Node’s Firebase Admin SDK to Dart.

 This project is still in its early stages, and some features may be missing or bugged. Currently, only Firestore is available, with more to come (auth next).

• Dart Firebase Admin
• Available features
• Usage
  • Connecting to the SDK
    • Connecting using the environment
    • Connecting using a service-account.json file
  • Using Firestore
  • Using Auth

Available features

Firestore
reference.id
reference.parent
reference.path
reference.==
reference.withConverter
collection.listDocuments
collection.add
collection.get
collection.create
collection.delete
collection.set
collection.update
collection.collection
query.where(‘field’, operator, value)
query.where(‘field.path’, operator, value)
query.where(FieldPath(‘…’), operator, value)
query.whereFilter(Filter.and(a, b))
query.whereFilter(Filter.or(a, b))
query.startAt
query.startAtDocument
query.startAfter
query.startAfterDocument
query.endAt
query.endAtDocument
query.endAfter
query.endAfterDocument
query.onSnapshot
query.select
query.orderBy
query.limit
query.limitToLast
query.offset
querySnapshot.docs
querySnapshot.readTime
querySnapshot.docsChange
documentSnapshots.data
documentSnapshots.readTime/createTime/updateTime
documentSnapshots.id
documentSnapshots.exists
documentSnapshots.data
documentSnapshots.get(fieldPath)
FieldValue.documentId
FieldValue.increment
FieldValue.arrayUnion
FieldValue.arrayRemove
FieldValue.delete
FieldValue.serverTimestamp
collectionGroup
runTransaction
GeoPoint
Timestamp
BundleBuilder

Auth
auth.tenantManager
auth.projectConfigManager
auth.generatePasswordResetLink
auth.generateEmailVerificationLink
auth.generateVerifyAndChangeEmailLink
auth.generateSignInWithEmailLink
auth.listProviderConfigs
auth.createProviderConfig
auth.updateProviderConfig
auth.getProviderConfig
auth.deleteProviderConfig
auth.createCustomToken
auth.setCustomUserClaims
auth.verifyIdToken
auth.revokeRefreshTokens
auth.createSessionCookie
auth.verifySessionCookie
auth.importUsers
auth.listUsers
auth.deleteUser
auth.deleteUsers
auth.getUser
auth.getUserByPhoneNumber
auth.getUserByEmail
auth.getUserByProviderUid
auth.getUsers
auth.createUser
auth.updateUser

Usage

Connecting to the SDK

Before using Firebase, we must first authenticate.

There are currently two options:

• You can connect using environment variables
• Alternatively, you can specify a service-account.json file

Connecting using the environment

To connect using environment variables, you will need to have the Firebase CLI installed.

Once done, you can run:

firebase login

And log-in to the project of your choice.

From there, you can have your Dart program authenticate using the environment with:

import 'package:dart_firebase_admin/dart_firebase_admin.dart';

void main() {
  final admin = FirebaseAdminApp.initializeApp(
    '<your project name>',
    // This will obtain authentication information from the environment
    Credential.fromApplicationDefaultCredentials(),
  );

  // TODO use the Admin SDK
  final firestore = Firestore(admin);
  firestore.doc('hello/world').get();
}

Connecting using a service-account.json file

Alternatively, you can choose to use a service-account.json file.
This file can be obtained in your firebase console by going to:

https://console.firebase.google.com/u/0/project/<your-project-name>/settings/serviceaccounts/adminsdk

Make sure to replace <your-project-name> with the name of your project. One there, follow the steps and download the file. Place it anywhere you want in your project.

 Note: This file should be kept private. Do not commit it on public repositories.

After all of that is done, you can now authenticate in your Dart program using:

import 'package:dart_firebase_admin/dart_firebase_admin.dart';

void main() {
  final admin = FirebaseAdminApp.initializeApp(
    '<your project name>',
    // Log-in using the newly downloaded file.
    Credential.fromServiceAccount(
      File('<path to your service-account.json file>'),
    ),
  );

  // TODO use the Admin SDK
  final firestore = Firestore(admin);
  firestore.doc('hello/world').get();
}

Using Firestore

First, make sure to follow the steps on how to authenticate. You should now have an instance of a FirebaseAdminApp object.

You can now use this object to create a Firestore object as followed:

// Obtained in the previous steps
FirebaseAdminApp admin;
final firestore = Firestore(admin);

From this point onwards, using Firestore with the admin ADK is roughly equivalent to using FlutterFire.

Using this Firestore object, you’ll find your usual collection/query/document objects.

For example, you can perform a where query:

// The following lists all users above 18 years old
final collection = firestore.collection('users');
final adults = collection.where('age', WhereFilter.greaterThan, 18);

final adultsSnapshot = await adults.get();

for (final adult in adultsSnapshot.docs) {
  print(adult.data()['age']);
}

Composite queries are also supported:

// List users with either John or Jack as first name.
firestore
  .collection('users')
  .whereFilter(
    Filter.or([
      Filter.where('firstName', WhereFilter.equal, 'John'),
      Filter.where('firstName', WhereFilter.equal, 'Jack'),
    ]),
  );

Alternatively, you can fetch a specific document too:

// Print the age of the user with ID "123"
final user = await firestore.doc('users/123').get();
print(user.data()?['age']);

Using Auth

First, make sure to follow the steps on how to authenticate. You should now have an instance of a FirebaseAdminApp object.

You can now use this object to create a FirebaseAuth object as followed:

// Obtained in the previous steps
FirebaseAdminApp admin;
final auth = FirebaseAuth(admin);

You can then use this FirebaseAuth object to perform various auth operations. For example, you can generate a password reset link:

final link = await auth.generatePasswordResetLink(
  '[email protected]',
);

The post A Firebase Admin SDK for Dart appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Used by

• Ubuntu Desktop Installer
• Ubuntu Flavor Installer
• Ubuntu Core Desktop Init
• Ubuntu Welcome

Configuration

Supported formats:

• TOML (.conf)

  [bootstrap]
  pages = "locale,keyboard,source,storage"
  
  [init]
  pages = "timezone,identity"

• YAML (.yaml, .yml)

  bootstrap:
    pages:
      - locale
      - keyboard
      - source
      - storage
  
  init:
    pages:
      - timezone
      - identity

Lookup order:

• /etc/ubuntu-provision.{conf,yaml,yml} (admin)
• /usr/local/share/ubuntu-provision.{conf,yaml,yml} (oem)
• /usr/share/ubuntu-provision.{conf,yaml,yml} (distro)
• <app>/data/flutter_assets/ubuntu-provision.{conf,yaml,yml} (app)

Translations

This project is being translated using Weblate, a web tool designed to ease translating for both developers and translators.

Contributing

See our contributor guidelines.

License

The Ubuntu Desktop Provision is licensed under the GNU General Public License version 3.

Download source code on GitHub

The post Ubuntu Desktop Provision appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

OpenScribe is an open-source editor app that aims to replace the standard Windows editor with advanced features.

Features

• Tabbed Editing : Open multiple notes in tabs to switch between them efficiently.
• Customizable User Experience : a custom window, custom colors, light, and dark modes, and multiple fonts for a unique user experience.
• Shortcuts : OpenScribe has a built-in keyboard shortcut to get work done.
• Ease of Use : The app is intuitive and easy to use, so you can focus on writing.
• Multiple Languages : OpenScribe is translated into multiple languages.
• Fast : OpenScribe has a fast startup time and is lightweight.
• Open Source : OpenScribe is an open-source project. You can view the source code and contribute to improve the app.

Installation

Go to the releases and install the latest release. Unzip the .zip file and run openscribe.exe.

Usage

• Create a new document with Ctrl + N or go to File -> New document

• Open an existing document with Ctrl + O or go to File -> Open

• Save the document with Ctrl + S or save as with Ctrl + Shift + S

• Switch between tabs with Ctrl + Tab or click on the tab

• Zoom in with Ctrl + Plus, zoom out with Ctrl + Minus, reset with Ctrl + 0 or go to View -> ...

• Open settings with Ctrl + , or click on the top right settings icon

• Get information about them with the info icon on the top right under the settings icon, hover over it to get the information

• Print the document with Ctrl + P or go to View -> Print

• Quit the app with Ctrl + Q

• Note

  • When changing to light mode, probably you have to adjust the primary color setting

License

This project is licensed under the MIT license. See the license file for more information.

Download source code on GitHub

The post OpenScribe is an open source editor app appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Internet Independent Wireless Mesh Communication App

qaul.net, To install and run qaul please see the Documentation.

License

qaul is a fully free and open source software. It is published under the AGPLv3, the GNU Affero General Public License version 3 or later.

Please see the licenses folder for in depth information on qaul’s licenses.

Committing and Contributing to qaul

Committing and contributing to this project, you agree to transfer the full copyright of all your contributions to the ‘Verein zur Förderung von offenen Community-Projekten‘ in Switzerland (English name: Open Community Project Association). This transfer includes the transfer of the following rights: the right to distribute the work, the right to modify the work, the right to enforce the copyright, the right to change the license of the work, the right to transfer ownership of the work as well as all exploitation rights of the work.

Download source code on GitHub

https://github.com/qaul/qaul.net

The post Internet Independent Wireless Mesh Communication App appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

FONNX

Any model on any edge

Run ML models natively on any platform. ONNX models can be run on iOS, Android, Web, Linux, Windows, and macOS.

What is FONNX?

FONNX is a Flutter library for running ONNX models. Flutter, and FONNX, run natively on iOS, Android, Web, Linux, Windows, and macOS. FONNX leverages ONNX to provide native acceleration capabilities, from CoreML on iOS, to Android Neural Networks API on Android, to WASM SIMD on Web. Most models can be easily converted to ONNX format, including models from Pytorch, Tensorflow, and more.

Getting ONNX Models

Hugging Face

Hugging Face has a large collection of models, including many that are ONNX format. 90% of the models are Pytorch, which can be converted to ONNX.

Here is a search for ONNX models.

Export ONNX from Pytorch, Tensorflow, & more

A command-line tool called optimum-cli from HuggingFace converts Pytorch and Tensorflow models. This covers the vast majority of models. optimum-cli can also quantize models, significantly reduce model size, usually with negligible impact on accuracy.

See official documentation or the quick start snippet on GitHub.
Another tool that automates conversion to ONNX is HFOnnx. It was used to export the text embeddings models in this repo. Its advantages included a significantly smaller model size, and incorporating post-processing (pooling) into the model itself.

• Brief intro to how ONNX model format & runtime work huggingface.com
• Netron allows you to view ONNX models, inspect their runtime graph, and export them to other formats

Text Embeddings

These models generate embeddings for text. An embedding is a vector of floating point numbers that represents the meaning of the text.
Embeddings are the foundation of a vector database, as well as retrieval augmented generation – deciding which text snippets to provide in the limited context window of an LLM like GPT.

Running locally using FONNX provides significant privacy benefits, as well as latency benefits. For example, rather than having to store the embedding and text of each chunk of a document on a server, they can be stored on-device. Both MiniLM L6 V2 and MSMARCO MiniLM L6 V3 are both the product of the Sentence Transformers project. Their website has excellent documentation explaining, for instance, semantic search

MiniLM L6 V2

Trained on a billion sentence pairs from diverse sources, from Reddit to WikiAnswers to StackExchange. MiniLM L6 V2 is well-suited for numerous tasks, from text classification to semantic search. It is optimized for symmetric search, where text is roughly of the same length and meaning. Input text is divided into approximately 200 words, and an embedding is generated for each.
Hugging Face

MSMARCO MiniLM L6 V3

Trained on pairs of Bing search queries to web pages that contained answers for the query. It is optimized for asymmetric semantic search, matching a search query to an answer. Additionally, it has 2x the input size of MiniLM L6 V2: it can accept up to 400 words as input for one embedding.
Hugging Face

Benchmarks

iPhone 14: 67 ms
Pixel Fold: 33 ms
macOS: 13 ms
WASM SIMD: 41 ms

Avg. ms for 1 Mini LM L6 V2 embedding / 200 words.

• Run on Thurs Oct 12th 2023.
• macOS and WASM-SIMD on MacBook Pro M2 Max.
• Average of 100 embeddings, after a warmup of 10.
• Input is Mix of lorem ipsum text from 8 languages.

Download source code on GitHub

https://github.com/Telosnex/fonnx

The post ONNX runtime for Flutter appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Screen Time API plugin for Flutter

A Flutter plugin for using Screen Time API. Only iOS is supported.

What is iOS Screen Time API?

• Screen Time | Apple Developer Documentation
• Meet the Screen Time API – WWDC21 – Videos
• What’s new in Screen Time API – WWDC22 – Videos

Features

• Show the screen selecting apps to discourage.
• Release all apps from discouraging.

Getting Started

1. Add the capability in Xcode

2. Request apple to use Family Control API

Usage

Select apps To discourage

final _screenTimeApiIosPlugin = ScreenTimeApiIos();
_screenTimeApiIosPlugin.selectAppsToDiscourage();

Release all apps from discouraging

final _screenTimeApiIosPlugin = ScreenTimeApiIos();
_screenTimeApiIosPlugin.encourageAll();

Contributing to this plugin

This plugin’s features are not enough. Please contribute to this plugin!

Download source code on GitHub

https://github.com/kboy-silvergym/screen_time_api_ios

The post A Flutter plugin for using iOS ScreenTime API appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Features

I work with this repo only when I have free time. But I don’t have enough )))

My main Idea is:

• Separate logic and presentation
  • Models: contains logic
  • UI: contains all UI widgets
  • bloc: use for binder between model and UI
• Create logic that calculates available way for figure
• Add “winning” logic | in progress |
  • Сheckmate logic
• Players take turns moving figures
• Add AI for playing with player | in hoping

Download source code on GitHub

https://github.com/baticpro/flutter-chess-game-bloc

The post Flutter chess game appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

ReCon

A Resonite Contacts App for Android

Get it here

Building

This is a standard Flutter application, refer to the Flutter docs on how to build it.

Currently, only Android is supported.

In theory, this app should also build fine for desktops, though not every feature will be functional. For example, voice messages and notifications are currently not supported on desktop builds.

Screenshots

Download source code on GitHub

https://github.com/Nutcake/ReCon

The post A Resonite Contacts App for Android appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Big thanks to Marcin Szałek for his article on Medium about this. Want to read it? Here’s the link

Flutter Parallax Scroll Effect preview

Download this widget source code on GitHub

https://github.com/abuanwar072/Flutter-Parallax-Effect

The post Parallax Scroll Effect with PageView in Flutter appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Goated Dart language.

This package is highly inspired by this Babel plugin

See the OG yt short: https://www.youtube.com/watch?v=vgcbwv_3WDU

Installation

To get your Glowup Vibes on, make sure you’ve got the Dart SDK installed on your machine.

Install via dart pub add:

dart pub add glowup_vibes

What?

Glowup Vibes is a Dart package that spices up Dart’s lingo with some “internet slang” flavor.

Why?

’cause.

API

Top-level getters:

Log APIs:

Based Mason Logger

Future APIs:

String APIs:

Other APIs:

Download and/or contribute to this package source code at

https://github.com/renancaraujo/glowup_vibes

The post Goated dart lang appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

A demo app that demonstrates Flutter’s ability to create beautiful UI with complex animations. The app fetches recipes from local storage.

Packages

Screenshot

Project Structure

|- assets <- recipe.json and images
|
lib
|
|_ 📁src
	|
	|__ 📁core
	|	|__ 📁animation <- page transition
	|	|__ 📁constants
	|	|__ 📁theme <- define themes & and colors
	|	|__ 📁widgets <- widgets that are used in multiple screens
	|
    	|__ 📁onboarding <- onboarding screen and its widgets
	|
	|__ 📁recipes 
        	|__ 📁domain <- entities
		|__ 📁data <- recipe repository (fetch recipes from recipe.json)
        	|__ 📁presentation <- Home Screen & Recipe Details Screen and other related widgets

Inspiration

Dribbble

License

MIT License

Download this UI source code on GitHub

https://github.com/Dev-Salem/dribbble_recipe_challenge

The post A Flutter app that demonstrates Flutter’s ability to create a beautiful UI appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Sections:

• Features
  • Library & Indexing
  • Look & Feel
  • Streaming
  • Others
  • Some additional cool features
• Video Integration
• Screenshots
• Usage Preview
• Installation
• Permission Note

Features

• Everything you might expect from a music player, in addition to the following:

Library & Indexing

• Powerful Indexer & Tag Editor, powered by @jaudiotagger.
• Artists and Genres Separators.
• Prevent Duplicated Tracks.
• Set Minimum File Size & Duration.
• Folders-based Library system, with the ability to exclude folders as well.
• Sort by almost any property of the track or the album.. etc.

Look & Feel

• Material3-like Theme.
• Dynamic Theming, Player Colors are picked from the current album artwork.
• Home, Tracks, Albums, Artists, Genres, Playlists, Queues and Folders Pages.
• Waveform Seekbar.
• Lots of customizations (check out customization section).

Streaming

• Best Video & Audio Quality
• Audio Only Mode
• Support Caching & Offline Playback
• Support Downloads
• Video View with gestures support (swipe to control volume, double tap to seek, swipe up/pinch in to enter fullscreen, etc)
• Edit tags for downloads
• Optional Auto title/artist/album extraction for downloads and scrobbling

Others:

• Sleep Timer (Tracks or Minutes)
• Play/Pause Fade Effect, along with Skip Silence.
• Control pausing scenarios (calls, notifications, volume 0, etc..)
• Define parameters to use for filtering tracks in search lists.
• Global Tracks Selection
  • allows u to select from multiple places into the same list.
• Never miss your sessions!
  • persistent and reliable queue system, your sessions are saved for later usage.
• Reliable History System
  • despite being a flexible system (easily modified, manipulated, imported), it lets u specifiy minimum seconds/percentage to count a listen.
• Most Played Playlist
  • find out your top tracks based on your history record.

Some additional cool features:

• Smort Tracks Generation:
  • uuh.. with dis advanced algorithm brought for you, u can generate tracks related to one you currently listening to, typically the ones that you often listened to in the same period. based on your history.
  • also u can generate tracks released around the same time, or from specific range of time, from ratings, from available moods, or randomly.
• Animating Thumbnail:
  • A thumbnail that animates with the current audio peak, looks cool.
• Miniplayer Party Mode:
  • Applies an edge breathing effect, colors can be static or dynamic (all the colors extracted from the artwork)
• Particles Effect
  • they speed up with the audio peak too
• Track Play Mode
  • when playing from search, you can selected wether to play: selected track only, search results, album, first artist or first genre.
• Insert after latest inserted
  • Want to insert multiple tracks one after each other? this will get your back.
• Repeat for N times
  • in addition to normal repeat modes (all, none, one), this one lets you repeat the track for a number of times before playing the next track.
• Extract feat. & ft. artists
  • You won’t miss the featured artists in the title, they’ll have their own entry inside the artist’s tab.

• CAN IMPORT YOUTUBE HISTORY.

• LASTFM TOO AND MAYBE MORE IN FUTURE.

• you gonna find decent amount of options/customizations in the settings and inside dialogs so make sure to check them out.

Video Integration

• For Local Library, Namida is capable of playing videos related to the music, Video can be found either locally or fetched from YouTube

Screenshots

Usage Preview

Installation

• Download latest version from releases page
• Available variants are arm & arm64

Permission Note:

the following actions require all_files_access permission (requested when needed)

• editing audio tags
• creating or restoring backups
• saving artworks
• compressing images
• downloading youtube content

Download source code on GitHub

https://github.com/namidaco/namida

The post A Beautiful and Feature-rich Music Player appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

An app to find repositories on Github and to view the various contributors to said repos.

About

This app aims to simplify the process of finding repositories on GitHub, view the various contributors to the repos, and also allow the user to become a contributor to the desired project.

Support open-source software by participating in Hacktoberfest and get goodies

Please check all issues labelled as hacktoberfest to start contributing!

Kindly consider leaving a if you like the repository and our organization.

Getting Started

• Fork it.

• Clone your forked repo and move inside it:
  git clone https://github.com/<your-github-username>/<repo-name>.git && cd <repo-name>

• Checkout to a new branch to work on an issue:
  git checkout -b my-amazing-feature

• Now you can open the project.

• Run flutter pub get in the project terminal and get the dependencies.

• Use flutter run debug to run the app in your local emulator.

• Once you’re all done coding, it’s time to open a PR Run the following commands from the root of the project directory:
  git add .
git commit -m "A short description about the feature."
git push origin <my-amazing-feature>

Open your forked repo in your browser and then raise a PR to the master branch of this repository!

Contributing

To start contributing, check out CONTRIBUTING.md. New contributors are always welcome to support this project. If you want something gentle to start with, check out issues labelled as easy or good-first-issue Check out issues labelled as hacktoberfest if you are up for some grabs!

License

This project is licensed under MIT

Download source code on GitHub

https://github.com/IEEE-VIT/hacktoberfest-flutter

The post Hacktoberfest 2023 with IEEE-VIT appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Welcome to the Flutter-TDD-Clean-Architecture-E-Commerce-App GitHub repository! This project is a showcase of modern mobile app development practices, leveraging the power of Flutter, Test-Driven Development (TDD), Clean Architecture, and the BLoC (Business Logic Component) package. Built using the latest version of Flutter 3, this E-Commerce application exemplifies best practices for building scalable, maintainable, and efficient Flutter apps.

Key Features:

• Test-Driven Development (TDD): This project emphasizes the importance of writing tests before writing the actual code. It ensures that the application’s logic is thoroughly tested, enhancing reliability and maintainability.
• Clean Architecture: The app follows a clean and modular architecture that separates concerns into different layers: Presentation, Domain, and Data. This architecture promotes code reusability and makes it easier to adapt to changes in the future.
• BLoC State Management: The app utilizes the BLoC pattern for state management. BLoC helps manage the flow of data and business logic in a clean and reactive manner, improving overall app performance.
• E-Commerce Functionality: The app showcases a variety of E-Commerce features, such as product browsing, searching, cart, and purchasing. Users can explore products, add them to their cart, and complete transactions seamlessly.

Demo Sample

Contributing:

We welcome contributions from the Flutter community to make this project even better. Whether you are interested in adding new features, fixing bugs, or improving documentation, your contributions are highly appreciated. Please refer to the contribution guidelines in the repository for more details on how to get involved.

Getting Started

To get started with this project, follow the instructions in the README to set up your development environment and run the app locally. You can also explore the project’s architecture, tests, and documentation to gain insights into building robust Flutter apps.

We hope this Flutter-TDD-Clean-Architecture-E-Commerce-App serves as a valuable resource for both Flutter enthusiasts and developers looking to learn about TDD, clean architecture, and BLoC in the context of mobile app development. Happy coding!

Installation

1. Clone the repo

   git clone https://github.com/Sameera-Perera/Flutter-TDD-Clean-Architecture-E-Commerce-App.git
2. Install packages

   flutter pub get
3. Run app

   flutter run lib/main.dart
4. Run test

   flutter test

For help getting started with Flutter, view our online documentation.

License

Distributed under the MIT License. See LICENSE for more information.

Download source code on GitHub

The post A modern E-Commerce mobile application appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.

Resonate – An Open Source Social Voice Platform

With the rising popularity of social voice platforms such as Clubhouse and Twitter Spaces, it is high time for an Open Source alternative. A platform like this would not only enhance credibility within the open-source community but also attract more users and foster growth. An engagement platform that is Open Source has the potential to drive significant traction and help establish a strong presence.

Features

1. Real-time Audio Communication by joining rooms and talking to people.
2. Ability to create rooms and moderate speakers and events.
3. Pair chatting to enable users to find random partners to talk to in the app.
4. Real-time messaging(Coming Soon)

Technologies Used

1. Flutter – Mobile application
2. Appwrite – Authentication, Database, Storage and Cloud functions.
3. LiveKit – Web Real-Time Communication

Repository Links

1. Resonate Flutter App
2. Resonate Backend

App Screenshots

Login Screen	Home Screen	Create Room Screen

Room Screen	Profile Screen	Pairchat Screen

Contributing

Don’t forget to star this repository if you find it useful!

Thank you for considering contributing to this project! Contributions are highly appreciated and welcomed. To ensure a smooth collaboration, Refer to the Contribution Guidelines.

We appreciate your contributions and look forward to working with you to make this project even better!

By following these guidelines, we can maintain a productive and collaborative open-source environment. Thank you for your support!

Check out the GitHub repository to download and/or contribute to the source code for this app

The post An Open Source Social Voice Platform appeared first on Flutter Packages | Pub dev Packages - Flutter Mobile App World.