onestudio-co / flutter-bond Goto Github PK

PART OF GTC OPEN SOURCE INTIATIVE

PART OF GTC OPEN SOURCE INTIATIVE

To improve the search capabilities in our Flutter application, we aim to integrate Algolia, a powerful search engine, into our app. Algolia provides advanced search features, such as typo tolerance, filtering, and relevance ranking, which will greatly enhance the search experience for our users. This issue focuses on integrating Algolia and utilizing its features to optimize search functionality within our app.

Key Objectives:

1. Research and understand Algolia's search engine capabilities, including typo tolerance, faceted filtering, and relevance ranking.
2. Integrate the Algolia SDK into our Flutter application, ensuring compatibility and seamless communication with the Algolia API.
3. Design and implement search interfaces within the app, allowing users to enter search queries and receive relevant results.
4. Utilize Algolia's typo tolerance feature to account for misspellings or slight variations in user search queries.
5. Implement faceted filtering to allow users to refine their search results based on specific criteria or categories.
6. Optimize search performance by leveraging Algolia's indexing and caching mechanisms.
7. Implement search result ranking based on relevance, ensuring that the most relevant results are displayed prominently.
8. Handle pagination of search results to accommodate large datasets and improve performance.
9. Implement error handling and feedback for cases where the Algolia integration encounters errors or fails to retrieve search results.
10. Write comprehensive unit and integration tests to verify the correctness and reliability of the Algolia integration.

Successful completion of this issue requires expertise in Flutter development, familiarity with Algolia's search engine capabilities, and the ability to integrate external APIs and SDKs seamlessly. The integration should enhance the search functionality, providing users with accurate and relevant search results.

Labels:

• Flutter
• Algolia
• Search Engine
• Search Optimization
• User Experience
• API Integration

PART OF GTC OPEN SOURCE INTIATIVE

When the appearance is changed, the icons remain inside the username and password fields, in addition to the cursor in purple color, and they become completely invisible.

PART OF GTC OPEN SOURCE INTIATIVE

Incorrect registration of the username and password causes the user to be blocked without showing a message informing him of that. Therefore, if he closes the application and reopens it again, the user gets stuck in the Splash even if the cache has been deleted.

Even if you made a login and got to the main screen and decided to click on the notification center button, the login screen opened.

PART OF GTC OPEN SOURCE INTIATIVE

Our Flutter application currently lacks an efficient mechanism for handling search input, resulting in unnecessary API calls or performance issues when users perform frequent or rapid searches. To enhance the user experience and optimize search functionality, we need to implement a Search Debouncer, which will delay and consolidate search requests based on user input. This issue aims to create a reusable Search Debouncer solution for our app.

Key Objectives:

1. Design and implement a Search Debouncer class or utility that can handle search input events and delay the execution of search requests.
2. Integrate the Search Debouncer into the app's search functionality to debounce user input, preventing frequent or unnecessary API calls.
3. Configure the debounce delay based on the application's requirements, balancing between responsiveness and reducing unnecessary network requests.
4. Provide an option to cancel or override a pending search request if the user modifies their input before the debounce delay elapses.
5. Implement proper error handling and feedback when search requests fail or encounter errors.
6. Ensure the Search Debouncer is easily configurable and reusable across different parts of the application.
7. Write unit tests to verify the functionality and reliability of the Search Debouncer.

To successfully complete this issue, the developer should have a solid understanding of Flutter development, event handling, and asynchronous programming. They should be able to create an efficient and reusable Search Debouncer that enhances the search functionality while maintaining a smooth user experience.

To be identical to Laravel framework in Api routing
You can use this library retrofit

PART OF GTC OPEN SOURCE INTIATIVE

. If you press 10 times, it will open 10 times on top of each other. (in Login Screen)

PART OF GTC OPEN SOURCE INTIATIVE

PART OF GTC OPEN SOURCE INTIATIVE

Hi @salahamassi 👋🏻

I have been encountering difficulties with loading pages on [flutter-bond]. Whenever I try to access different pages, they fail to load correctly. Instead, I am either presented with a blank page or the loading process takes an unusually long time. I have attempted to refresh the pages multiple times, but the issue persists.

Steps to Reproduce:

Open flutter bond.
Navigate to any page ( homepage,).
Observe that the page fails to load properly.

Expected Behavior:
I expect the pages on to load promptly and display the relevant content without any delays or errors.

Actual Behavior:
Instead of loading the pages as expected, I am encountering issues such as blank screens or significantly delayed loading times. This prevents me from accessing the desired content effectively.

I kindly request your prompt attention to this matter, as the inability to load pages is hindering my usage of . Your assistance in resolving this issue would be greatly appreciated.

Thank you for your attention and support.

PART OF GTC OPEN SOURCE INTIATIVE

Currently, our Flutter application lacks a standardized way to display errors to the user. We need to create a reusable and generic error widget that can handle and present various types of errors, including unexpected errors that may occur during runtime. This issue aims to implement a robust solution that improves the user experience by providing clear and consistent error messages.

Key Objectives:

1. Design and implement a generic error widget that can be easily integrated into any part of the application.
2. Support different types of errors, including network errors, API errors, validation errors, and unexpected errors.
3. Customize the error widget to display relevant error messages, error codes, and any additional information that might help users or developers understand the issue.
4. Provide user-friendly error messages that are concise, easy to understand, and guide the user toward resolving the error.
5. Include appropriate styling and visual cues to make the error widget visually distinct and attention-grabbing.
6. Implement error logging and reporting functionality to capture and track errors for debugging purposes.

To successfully complete this issue, the developer should have a solid understanding of Flutter development, UI design principles, and error handling. They should be able to create a reusable and customizable widget that can be easily maintained and extended.

Labels:

• Flutter
• Error Handling
• User Interface
• Reusability
• Logging

in apiconfig.dart file when put baseurl as a variable,
make a split like this :

class ApiConfig{
// we put api url because we need to add image without api urn
static const _baseUrl = "http://demo-api.mr-dev.tech/";

static const _apiUrl = _baseUrl+ "api/";
static const users = _apiUrl + 'users';
}

https://laravel.com/docs/9.x/cache

PART OF GTC OPEN SOURCE INTIATIVE

The flutter-bond repo currently does not handle any internet connection messages. This can lead to unexpected behavior, such as errors or blank screens.

For example, if a user tries to access a feature that requires an internet connection, but they do not have an internet connection, the app will crash or show a blank screen.

Proposed Solution

We should add a new feature to handle no internet connection messages. This feature could do the following:

1. Check the internet connection before making any requests.
2. Display a letter to the user if there is no internet connection.
3. Allow the user to retry the request when the internet connection is restored.

Benefits

This feature would improve the usability of the flutter-bond repo and make it more user-friendly. It would also prevent users from experiencing unexpected behavior when they do not have an internet connection.

Steps to Reproduce

1. Open the flutter-bond app.
2. Try to use a feature that requires an internet connection.
3. You will see an error message or a blank screen or just loading.

Expected Behavior

When the user tries to use a feature that requires an internet connection and there is no internet connection, the app should display a message to the user and allow them to retry the request when the internet connection is restored.

Actual Behavior

When the user tries to use a feature that requires an internet connection and there is no internet connection, the app will show an error message or a blank screen.

Additional Details

• Severity: Is it a critical issue that prevents the app from working at all, or is it a less serious issue that only affects certain features?
• Steps to Reproduce: What steps can a user take to reproduce the issue?
• Expected Behavior: What should happen when the user tries to use the app when there is no internet connection?
• Actual Behavior: What actually happens when the user tries to use the app in a situation where there is no internet connection?

Thanks for your consideration!

PART OF GTC OPEN SOURCE INTIATIVE

Currently, our Flutter application lacks an automated mechanism to check for updates from the App Store. To enhance the user experience and ensure that our users have the latest version of the app, we need to implement a library that can automatically check for updates using data retrieved from the App Store. This issue aims to create a solution that fetches and compares version information from the App Store, utilizing a configuration from an external resource.

Key Objectives:

Design and implement a library that can retrieve version information from the App Store using the provided app's identifier or bundle identifier.
Integrate the library with the Flutter application to automatically check for updates at regular intervals or upon app launch.
Use an external configuration file or resource to specify the frequency of update checks and any additional parameters, such as update notifications or forced updates.
Compare the retrieved version information with the current version of the app installed on the user's device.
Provide appropriate user feedback and notifications if a new version is available, allowing the user to choose whether to update or defer the update.
Handle edge cases, such as handling different App Store regions, handling errors during update checks, and gracefully degrading when network connectivity is not available.
Ensure the library is well-documented and easy to configure, allowing developers to integrate it into their Flutter applications seamlessly.
To successfully complete this issue, the developer should have a solid understanding of Flutter development, working with external APIs (such as the App Store API), and implementing automatic update checks. They should be able to create a reusable library that simplifies the process of checking for app updates and enhances the user experience.

Labels:

Flutter
Library
App Store
Update Checks
User Experience
External Configuration
API Integration

PART OF GTC OPEN SOURCE INTIATIVE

for e.x:
if I want to get remote data if I have a connection with the internet,
and if I don't have internet, I want to get data from local,
I think we want
internet_connection_checker
or connectivity_plus

PART OF GTC OPEN SOURCE INTIATIVE

After I create feature from command(dart run ./generator/generator.dart todo -m task) , the model in this feature can't make inherent from Model Class

When I generate the feature, the generator didn't add registerFactory to ServiceProvider

• Getx router
• Getx state management
• Getx service locator
• Getx tests

PART OF GTC OPEN SOURCE INTIATIVE

If the login button is clicked too many times and its status is disable then the application is closed and opened again, the user gets stuck in the splash (after several minutes it works normally) even if the cache is cleared.

we need to handle cache exception to
declare what failure when getting data from local?!

PART OF GTC OPEN SOURCE INTIATIVE

As a developer, I need to implement proper handling of device permissions in my Flutter app to ensure a smooth and secure user experience. Currently, the app lacks the necessary logic to handle various permissions, such as camera, microphone, location, storage, etc. This issue aims to address this by implementing a robust permission handling system.

The main objectives of this issue are:

1. Create a centralized permission management module that can be easily integrated into any Flutter app.
2. Implement a permission request flow that guides the user through the process of granting or denying permissions.
3. Handle different permission scenarios, including cases where permissions are denied or revoked.
4. Provide clear and user-friendly explanations for why each permission is required and how it will be used.
5. Support runtime permission requests to ensure that permissions are obtained when they are actually needed.
6. Implement proper error handling and graceful degradation when permissions are not granted.

This issue requires an understanding of Flutter development, knowledge of platform-specific permission APIs (e.g., Android's PackageManager or iOS's Info.plist), and the ability to create a well-designed and reusable module that can be easily maintained and extended.

Labels:

• Flutter
• Permissions
• User Experience
• Error Handling
• User Interface

You are using the Dio package
For a special addition, you can use pretty_dio_logger to print the request in terminal

PART OF GTC OPEN SOURCE INTIATIVE

Our Flutter application currently lacks a centralized and efficient mechanism for handling API request states. To improve the codebase and provide a seamless user experience, we need to implement a Request Provider using Riverpod, a state management library for Flutter. This issue aims to create a Request Provider that can manage API request states, including loading, success, and error states, in a consistent and scalable manner.

Key Objectives:

1. Design and implement a Request Provider using Riverpod to manage API request states throughout the application.
2. Define state models for different request states, including loading, success, and error.
3. Handle loading state to display appropriate loading indicators or progress bars during API requests.
4. Handle success state to propagate the retrieved data to the relevant UI components.
5. Handle error state to display error messages and provide feedback to the user in case of API failures.
6. Implement appropriate error handling mechanisms, such as retrying failed requests or displaying error details.
7. Ensure that the Request Provider is easily accessible and can be consumed by different parts of the application.

To successfully complete this issue, the developer should have a good understanding of Riverpod and its integration with Flutter, as well as experience in handling API requests and managing state. They should be able to create a robust and reusable Request Provider that enhances the application's architecture and improves the overall user experience.

Labels:

• Flutter
• Riverpod
• State Management
• API Requests
• Error Handling
• User Interface

When I used API_BASE_URL in env, this return null in baseUrl variable in ApiConfig class,
and to solve it you should add a default value.
class ApiConfig { static var baseUrl = env('API_BASE_URL','http://10.0.2.2:8000/api/'); }

PART OF GTC OPEN SOURCE INTIATIVE

https://parseplatform.org/Parse-SDK-Android/api/com/parse/ParseQuery.CachePolicy.html

PART OF GTC OPEN SOURCE INTIATIVE

Hi @salahamassi,

thank you and your team for a great work, I have a comment maybe help you on your framework.

I have a suggestion for improving the registration process for custom cache drivers in flutter-bond. Currently, the documentation suggests editing the CacheServiceProvider file and registering the custom class using GetIt. However, I think this approach has some drawbacks.

Problem

Passing the GetIt object to the developer can potentially cause security and stability issues. The developer can unregister and override dependencies, which can lead to unexpected behavior.

Proposed Solution

I propose that the registration function should return a Future of List cache drivers instead of taking the GetIt object as a parameter. This way, the framework can handle the registration process and ensure that the custom driver is registered correctly.

Here's an example of how the registration function can be implemented:

Future<List<CacheDriver>> register() async {
  var store = CacheConfig.defaultStore;
  var defaultStoreDriver = CacheConfig.stores[store]?['driver'];

  List<CacheDriver> customDrivers = [];
  
  CacheConfig.stores.forEach((key, value) {
    if (value['driver'] == defaultStoreDriver) {
      customDrivers.add(SharedPreferencesCacheDriver(GetIt.instance));
    } else {
      if (value['driver'] == 'in_memory') {
        customDrivers.add(InMemoryCacheDriver(GetIt.instance));
      }
    }
  });

  return Future.value(customDrivers);
}

Trade-offs

This approach may limit the flexibility of the framework and prevent advanced users from customizing the behavior of the cache driver. However, I believe that the benefits of improved security and stability outweigh the drawbacks.

Please let me know if you have any feedback or suggestions.
Thank you for your attention.

PART OF GTC OPEN SOURCE INTIATIVE

PART OF GTC OPEN SOURCE INTIATIVE

We need to implement a dynamic feature flag system, and a flutter split io driver for this feature flag system

PART OF GTC OPEN SOURCE INTIATIVE

PART OF GTC OPEN SOURCE INTIATIVE

PART OF GTC OPEN SOURCE INTIATIVE

When the Show Password button is clicked in the Confirm Password field, the password is displayed in both fields and vice versa

e.x: JSON format return from API:

{"author":"Unknown","id":21,"quote":"XML is like violence \u2013 if it doesn\u2019t solve your problems, you are not using enough of it.","permalink":"http://quotes.stormconsultancy.co.uk/quotes/21"}

PART OF GTC OPEN SOURCE INTIATIVE

The rest of the error message related to confirming the password does not appear because the specified space has expired.

PART OF GTC OPEN SOURCE INTIATIVE

If I enter the system after logging in and close the application and open it again, it will return me to the login screen.

PART OF GTC OPEN SOURCE INTIATIVE

To keep up with the latest trends and improve the visual appeal of our application, we should start incorporating UI extensions and adopting popular styling theme trends. This issue focuses on embracing new UI extension libraries and following modern styling themes to enhance the overall look and feel of our application.

Key Objectives:

1. Research and identify popular UI extension libraries and styling theme trends in the Flutter ecosystem.
2. Evaluate the compatibility and suitability of these libraries and themes for our application's architecture and design.
3. Select one or more UI extension libraries that align with our project's requirements and desired visual aesthetics.
4. Integrate the chosen UI extension library into our Flutter application, ensuring proper configuration and compatibility.
5. Update our application's UI components to utilize the extended functionality and enhanced styling provided by the UI extension library.
6. Explore and adopt modern styling themes to align our application's visual design with the latest trends.
7. Implement the chosen styling theme, ensuring consistency across different screens and components.
8. Customize the styling theme to match our brand identity and desired user experience.
9. Conduct thorough testing to ensure that the updated UI and styling do not introduce any regressions or compatibility issues.
10. Document the adopted UI extension library and styling theme, providing guidelines and best practices for future development and maintenance.

Successful completion of this issue requires a deep understanding of Flutter development, familiarity with popular UI extension libraries and styling theme trends, and the ability to seamlessly integrate them into the existing codebase. The adoption of new UI extensions and styling themes should enhance the application's visual appeal and keep it aligned with modern design trends.

Labels:

• Flutter
• UI Extension
• Styling Theme
• User Interface
• User Experience
• Modern Design Trends