App Badge Plus

https://github.com/windows7lake/app_badge_plus
Admin
App Badge Plus is a Flutter plugin for adding badges to your app icon, with support for iOS,...
Tokens:24,350
Snippets:312
Trust Score:6.4
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example pubspec.yaml with Permissions

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

An example pubspec.yaml file demonstrating the inclusion of app_badge_plus, permission_handler, and flutter_local_notifications dependencies.

```yaml
name: my_app
description: My Flutter app with badge support
version: 1.0.0

environment:
  sdk: ^3.8.0
  flutter: '>=3.32.0'

dependencies:
  flutter:
    sdk: flutter
  app_badge_plus: ^1.3.0
  permission_handler: ^11.0.0
  flutter_local_notifications: ^16.0.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_lints: ^5.0.0

flutter:
  uses-material-design: true

```

--------------------------------

### Get Installed Launcher List

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Retrieves a list of all installed launcher applications, with the default launcher moved to the front. Optionally includes FallbackHome. Use this to display a list of available launchers to the user.

```kotlin
val launchers = LauncherTool.getLauncherList(context)
for (launcherInfo in launchers) {
    println("Launcher: ${launcherInfo?.activityInfo?.packageName}")
}
```

--------------------------------

### Iterate Through Installed Launchers

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Retrieves a sorted list of installed launchers and prints their package names along with their index. The default launcher is always at index 0.

```kotlin
val launchers = LauncherTool.getLauncherList(context)
println("Default launcher: ${launchers[0]?.activityInfo?.packageName}")

for ((index, launcher) in launchers.withIndex()) {
    println("$index: ${launcher?.activityInfo?.packageName}")
}
```

--------------------------------

### Dart example for isSupported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

An example of how to invoke the 'isSupported' method from Dart to check if badge functionality is available on the device.

```dart
final supported = await methodChannel.invokeMethod<bool>('isSupported');
```

--------------------------------

### LauncherTool.getLauncherList

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Gets a list of all installed launcher applications. This is a utility function for Android badge functionality.

```APIDOC
## LauncherTool.getLauncherList

### Description
Gets a list of all installed launcher applications.

### Method
```kotlin
fun getLauncherList(
    context: Context,
    includeFallbackHome: Boolean = true
): List<ResolveInfo?>
```

### Parameters
#### Path Parameters
- **context** (Context) - Required - Android application context
- **includeFallbackHome** (Boolean) - Optional - Default: `true` - Whether to include FallbackHome in results

### Return Type
`List<ResolveInfo?>` - list of launcher ResolveInfo, with default launcher first

### Behavior
- Queries all apps with ACTION_MAIN + CATEGORY_HOME intent
- Filters out FallbackHome unless explicitly requested
- Moves the default/current launcher to the front of the list
- Uses PackageManager.MATCH_ALL on Android M+

### Algorithm
1. Query all apps matching ACTION_MAIN + CATEGORY_HOME
2. Filter out FallbackHome if `includeFallbackHome` is false
3. Find the default launcher using `resolveActivity()`
4. Move default launcher to position 0
5. Return modified list

### Example
```kotlin
val launchers = LauncherTool.getLauncherList(context)
for (launcherInfo in launchers) {
    println("Launcher: ${launcherInfo?.activityInfo?.packageName}")
}
```

### Note
The default launcher is always at index 0 of the returned list.
```

--------------------------------

### Example Usage of Badge

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Demonstrates how to check if badge support is available and then update the badge count if it is supported. This is a common pattern for integrating badge functionality.

```kotlin
val isSupported = Badge.isBadgeSupported(context)
if (isSupported) {
    Badge.updateBadge(context, 5)
}
```

--------------------------------

### Example AndroidManifest.xml with Badge Permissions

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

This AndroidManifest.xml includes standard internet and notification permissions, along with specific badge permissions required for Samsung and Huawei devices.

```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    
    <!-- Standard permissions -->
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
    
    <!-- Badge permissions for Samsung -->
    <uses-permission android:name="com.sec.android.provider.badge.permission.READ"/>
    <uses-permission android:name="com.sec.android.provider.badge.permission.WRITE"/>
    
    <!-- Badge permissions for Huawei -->
    <uses-permission android:name="com.huawei.android.launcher.permission.CHANGE_BADGE"/>
    <uses-permission android:name="com.huawei.android.launcher.permission.READ_SETTINGS"/>
    <uses-permission android:name="com.huawei.android.launcher.permission.WRITE_SETTINGS"/>
    
    <application
        android:label="My App"
        android:icon="@mipmap/ic_launcher">
        
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>
</manifest>

```

--------------------------------

### Get Supported Launchers

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Retrieves a list of package names for launchers that the current badge implementation supports. This is useful for understanding compatibility.

```kotlin
fun getSupportLaunchers(): List<String>
```

```kotlin
override fun getSupportLaunchers(): List<String> {
    return listOf(
        "com.sec.android.app.launcher",
        "com.sec.android.app.twlauncher"
    )
}
```

--------------------------------

### Set Badge Count using flutter_app_badger

Source: https://github.com/windows7lake/app_badge_plus/blob/main/README.md

This is an example of how to set a badge count using the flutter_app_badger package.

```dart
FlutterAppBadger.updateBadgeCount(1);
```

--------------------------------

### Android Launcher Utility Methods

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

Provides utility functions for querying and managing launcher applications on Android. These include getting class names, component names, and a list of available launchers.

```kotlin
object LauncherTool {
    fun getClassName(context: Context): String { ... }
    fun getComponentName(context: Context): ComponentName? { ... }
    fun getLauncherList(context: Context, includeFallbackHome: Boolean = true): List<ResolveInfo?> { ... }
    
    private fun makeSureLauncherOnTop(defaultActivity: ResolveInfo?, resolveList: MutableList<ResolveInfo>) { ... }
    private fun isFallbackHome(resolveInfo: ResolveInfo?): Boolean { ... }
}
```

--------------------------------

### Check App Badge Support During Initialization

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus.md

This example shows how to check for app badge support when the widget is first initialized. The result is stored in a state variable, allowing the UI to react accordingly. This is useful for conditionally enabling badge-related features.

```dart
@override
void initState() {
  super.initState();
  _checkBadgeSupport();
}

void _checkBadgeSupport() async {
  bool supported = await AppBadgePlus.isSupported();
  setState(() {
    _badgeSupported = supported;
  });
}
```

--------------------------------

### Check App Badge Support using flutter_app_badger

Source: https://github.com/windows7lake/app_badge_plus/blob/main/README.md

This is an example of how to check if app badges are supported using the flutter_app_badger package.

```dart
FlutterAppBadger.isAppBadgeSupported();
```

--------------------------------

### Get Android Launcher List

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Retrieve a list of available launchers on an Android device for debugging purposes. This helps identify which launchers are active.

```kotlin
val launchers = LauncherTool.getLauncherList(context)
Log.i("Debug", "Launchers: ${launchers.map { it?.activityInfo?.packageName }}")
```

--------------------------------

### Concurrent Safe Usage Example

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Demonstrates how to safely call updateBadge concurrently from multiple Dart threads using Future.wait.

```dart
// All safe to call concurrently
await Future.wait([
    AppBadgePlus.updateBadge(1),
    AppBadgePlus.updateBadge(2),
    AppBadgePlus.updateBadge(3),
]);
```

--------------------------------

### Check for Specific Launcher Presence

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Determines if a specific launcher package, such as 'com.sec.android.app.launcher', is present in the list of installed launchers.

```kotlin
val launchers = LauncherTool.getLauncherList(context)
val hasSamsungLauncher = launchers.any { 
    it?.activityInfo?.packageName == "com.sec.android.app.launcher"
}
println("Samsung launcher present: $hasSamsungLauncher")
```

--------------------------------

### Update Dock Tile Badge Label

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

Directly sets the badge label on the application's dock tile. This example shows setting the badge to '5'.

```swift
NSApplication.shared.dockTile.badgeLabel = "5"
```

--------------------------------

### Invoke Is Supported Method from Dart

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/ios_plugin.md

Example of how to invoke the 'isSupported' method from Dart to check if badge functionality is available.

```dart
final supported = await channel.invokeMethod<bool>('isSupported');
print('Badge supported: $supported');  // Always prints true
```

--------------------------------

### Invoke Update Badge Method from Dart

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/ios_plugin.md

Example of how to invoke the 'updateBadge' method from Dart using a FlutterMethodChannel.

```dart
try {
    await channel.invokeMethod<void>('updateBadge', {'count': 5});
} on PlatformException catch (e) {
    print('Failed to update badge: ${e.message}');
}
```

--------------------------------

### Get and Set Instance of AppBadgePlusPlatform

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

Allows retrieval and modification of the current platform-specific badge implementation. Useful for testing by injecting custom implementations.

```dart
static AppBadgePlusPlatform get instance
static set instance(AppBadgePlusPlatform instance)
```

```dart
// Get the current implementation
AppBadgePlusPlatform implementation = AppBadgePlusPlatform.instance;

// Set a custom implementation for testing
AppBadgePlusPlatform.instance = CustomBadgeImplementation();
```

--------------------------------

### LauncherTool.getComponentName

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Gets the component name of the app's launch activity. This is a utility function for Android badge functionality.

```APIDOC
## LauncherTool.getComponentName

### Description
Gets the component name of the app's launch activity.

### Method
```kotlin
fun getComponentName(context: Context): ComponentName?
```

### Parameters
#### Path Parameters
- **context** (Context) - Required - Android application context

### Return Type
`ComponentName?` - component name or null if not found

### Example
```kotlin
val component = LauncherTool.getComponentName(context)
println("${component?.packageName}/${component?.className}")
```
```

--------------------------------

### Accessing Dock Tile Badge Label

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

This snippet shows how to access the shared NSApplication instance to get the dock tile's badge label. It is available in all supported macOS versions.

```swift
NSApplication.shared
    .dockTile
    .badgeLabel
```

--------------------------------

### Invoke Update Badge Method (Dart)

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

Example of invoking the 'updateBadge' method from Dart to show a badge with a count of 5.

```dart
// Show badge with count
await channel.invokeMethod<void>('updateBadge', {'count': 5});
```

--------------------------------

### LauncherTool.getClassName

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Gets the class name of the app's launch activity. This is a utility function for Android badge functionality.

```APIDOC
## LauncherTool.getClassName

### Description
Gets the class name of the app's launch activity.

### Method
```kotlin
fun getClassName(context: Context): String
```

### Parameters
#### Path Parameters
- **context** (Context) - Required - Android application context

### Return Type
`String` - fully qualified class name (e.g., `"com.example.MainActivity"`), or empty string if not found

### Example
```kotlin
val className = LauncherTool.getClassName(context)
println(className)  // e.g., "com.example.MainActivity"
```
```

--------------------------------

### Get App's Main Activity Component

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Retrieves the main activity class name and component name for the application context. Useful for identifying the primary entry point of an app.

```kotlin
val className = LauncherTool.getClassName(context)
val component = LauncherTool.getComponentName(context)

println("Package: ${component?.packageName}")
println("Class: ${className}")
```

--------------------------------

### Android Log Tags for Debugging

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Examples of log messages used by the AppBadgePlus plugin on Android for debugging purposes. Use 'adb logcat Badge:V' to view these logs.

```kotlin
Log.d(TAG, "Checking if launcher supports badge, attempt ${i + 1}")
Log.e(TAG, "Failed to initialize badge")
Log.i(TAG, "Checking launcher $activityInfo")
Log.e(TAG, "Unable to update badge", exception)
```

--------------------------------

### Get App Launch Activity Class Name

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Retrieves the fully qualified class name of the app's launch activity. Returns an empty string if the activity is not found. Use this when you need the specific class name for an activity.

```kotlin
val className = LauncherTool.getClassName(context)
println(className)  // e.g., "com.example.MainActivity"
```

--------------------------------

### Get App Launch Activity Component Name

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Retrieves the ComponentName of the app's launch activity. Returns null if the activity is not found. This is useful for identifying the launch activity by its package and class name.

```kotlin
val component = LauncherTool.getComponentName(context)
println("${component?.packageName}/${component?.className}")
```

--------------------------------

### getSupportLaunchers()

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Retrieves a list of launcher package names that the current badge implementation supports. This is useful for understanding compatibility with different device launchers.

```APIDOC
## getSupportLaunchers()

### Description
Returns a list of launcher package names that this badge implementation supports.

### Method
`fun getSupportLaunchers(): List<String>`

### Return Type
`List<String>` — launcher package names (e.g., `com.sec.android.app.launcher`)

### Example
```kotlin
// Example from Samsung implementation:
override fun getSupportLaunchers(): List<String> {
    return listOf(
        "com.sec.android.app.launcher",
        "com.sec.android.app.twlauncher"
    )
}
```
```

--------------------------------

### Remove Badge using flutter_app_badger

Source: https://github.com/windows7lake/app_badge_plus/blob/main/README.md

This is an example of how to remove a badge using the flutter_app_badger package.

```dart
FlutterAppBadger.removeBadge();
```

--------------------------------

### Initialize Badge Provider

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Initializes the badge provider by detecting the current launcher. This method attempts to find and instantiate compatible badge implementations by querying available launcher apps.

```kotlin
private fun initBadge(context: Context): Boolean
```

--------------------------------

### Invoke Clear Badge Method (Dart)

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

Example of invoking the 'updateBadge' method from Dart to clear the badge.

```dart
// Clear badge
await channel.invokeMethod<void>('updateBadge', {'count': 0});
```

--------------------------------

### Detect Badge Implementation for Launcher

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Iterates through a list of supported badge implementations to find one that supports the current launcher package. Requires the context and a predefined list of BADGES.

```kotlin
val launchers = LauncherTool.getLauncherList(context)

for (launcher in launchers) {
    val packageName = launcher?.activityInfo?.packageName
    
    for (badgeClass in BADGES) {
        val badge = badgeClass.newInstance()
        if (badge.getSupportLaunchers().contains(packageName)) {
            return badge  // Found a match
        }
    }
}
```

--------------------------------

### Platform Architecture Overview

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/README.md

Illustrates the plugin's platform architecture, showing the flow from the Dart application down to the native implementations on Android, iOS, and macOS.

```plaintext
Dart App
  ↓
AppBadgePlus (static facade)
  ↓
AppBadgePlusPlatform (abstract interface)
  ↓
MethodChannelAppBadgePlus (default implementation)
  ↓
Method Channel ("app_badge_plus")
  ↓
Native Implementation
  ├─ Android: AppBadgePlusPlugin → Badge → IBadge implementations
  ├─ iOS: AppBadgePlusPlugin → UNUserNotificationCenter
  └─ macOS: AppBadgePlusPlugin → NSApplication.dockTile
```

--------------------------------

### File Organization Structure

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/README.md

This snippet shows the directory structure of the app_badge_plus plugin project, outlining the location of key documentation files and API reference modules.

```plaintext
output/
├── README.md                          [This file]
├── types.md                           [Type definitions]
├── errors.md                          [Error handling]
├── endpoints.md                       [Method channel protocol]
├── configuration.md                   [Setup instructions]
└── api-reference/
    ├── app_badge_plus.md             [Main Dart API]
    ├── app_badge_plus_platform_interface.md
    ├── android_badge.md              [Badge detection & updates]
    ├── android_plugin.md             [Android native bridge]
    ├── android_utilities.md          [Launcher detection utilities]
    ├── ios_plugin.md                 [iOS native bridge]
    └── macos_plugin.md               [macOS native bridge]
```

--------------------------------

### Handle BadgeException

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Demonstrates how to catch and log a BadgeException, which is thrown when a badge update fails. This is crucial for error handling in badge operations.

```kotlin
constructor(message: String)
```

```kotlin
constructor(message: String, cause: Throwable)
```

```kotlin
try {
    Badge.updateBadge(context, count)
} catch (e: BadgeException) {
    Log.e("BadgeUpdate", "Failed: ${e.message}", e)
}
```

--------------------------------

### Minimum Project Configuration (pubspec.yaml)

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

This is the basic structure for a Flutter project's pubspec.yaml file, including essential dependencies for the app_badge_plus plugin.

```yaml
name: app_badge_plus
description: A Flutter plugin for adding badges to your app icon.
version: 1.3.0
environment:
  sdk: ^3.8.0
  flutter: '>=3.32.0'

dependencies:
  flutter:
    sdk: flutter
  plugin_platform_interface: ^2.1.8

flutter:
  plugin:
    platforms:
      android:
        package: me.liolin.app_badge_plus
        pluginClass: AppBadgePlusPlugin
      ios:
        pluginClass: AppBadgePlusPlugin
      macos:
        pluginClass: AppBadgePlusPlugin

```

--------------------------------

### isSupported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

Checks if the macOS dock tile badge functionality is supported. This method always returns true on macOS.

```APIDOC
## isSupported Method

### Description
Checks if the dock tile badge functionality is supported on the current macOS system. This method always returns true.

### Method
`isSupported()`

### Endpoint
`app_badge_plus` (Method Channel)

### Parameters
None

### Request Example
```dart
final supported = await channel.invokeMethod<bool>('isSupported');
print('Badge supported: $supported'); // Always prints true
```

### Response
#### Success Response
- **Return Value**: Boolean (`true`)

### Behavior
macOS always supports dock tile badges.
```

--------------------------------

### Android App Build Configuration (build.gradle)

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

Standard Android Gradle configuration for the app module. The plugin is typically included automatically via pubspec.

```gradle
dependencies {
    // Plugin automatically included via pubspec
}

```

--------------------------------

### isSupported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Checks if the platform supports application badge customization. This method is available on Android, iOS, and macOS.

```APIDOC
## isSupported

### Description
Checks if the current platform supports the functionality to customize application badges. This operation is asynchronous and returns a Future that completes with a boolean value.

### Method
GET

### Endpoint
/isSupported

### Parameters
No parameters are required for this method.

### Request Example
```json
{
  "method": "isSupported",
  "args": null
}
```

### Response
#### Success Response (200)
- **result** (boolean) - True if the platform supports badges, false otherwise.

#### Response Example
```json
{
  "result": true
}
```
```

--------------------------------

### Mocking App Badge Plus for Unit Tests

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

Set up a mock implementation of the App Badge Plus platform interface to isolate your tests. This ensures that badge updates are predictable and don't rely on actual platform behavior.

```dart
import 'package:app_badge_plus/app_badge_plus_platform_interface.dart';

// Mock implementation for testing
class MockBadgePlus extends AppBadgePlusPlatform {
    @override
    Future<void> updateBadge(int count) async {
        print('Mock: Badge updated to $count');
    }
    
    @override
    Future<bool> isSupported() async => true;
}

void main() {
    setUp(() {
        AppBadgePlusPlatform.instance = MockBadgePlus();
    });
    
    test('Badge update', () async {
        await AppBadgePlus.updateBadge(5);
    });
}
```

--------------------------------

### Check Notification Permission Status (Android)

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Get the current status of the notification permission on Android. This is crucial for diagnosing issues related to badge updates.

```dart
final status = await Permission.notification.status;
print('Notification permission: $status');
```

--------------------------------

### Update Badge Count

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Updates the app icon badge count, wrapping the throwing version with exception handling. If no badge provider is initialized, it calls `initBadge()` to detect launchers. It delegates to the platform-specific `IBadge` implementation and catches/logs any `BadgeException` without throwing.

```kotlin
fun updateBadge(context: Context, count: Int)
```

--------------------------------

### Thread Handling Across Platforms

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/README.md

Summarizes how different platforms (Android, iOS, macOS) handle threading for plugin operations, ensuring safe calls from any thread.

```plaintext
Android | Main thread dispatch (method channel)
iOS | Main thread dispatch via DispatchQueue.main.async
macOS | Main thread dispatch via DispatchQueue.main.async
```

--------------------------------

### AppBadgePlus.isSupported()

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus.md

Checks whether the current platform supports app badges. Returns a boolean indicating support.

```APIDOC
## AppBadgePlus.isSupported()

### Description
Checks whether the current platform supports app badges.

### Method
static Future<bool>

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```dart
import 'package:app_badge_plus/app_badge_plus.dart';

final isSupported = await AppBadgePlus.isSupported();
if (isSupported) {
  print('App badges are supported on this device');
  await AppBadgePlus.updateBadge(1);
} else {
  print('App badges are not supported');
}
```

### Response
#### Success Response (bool)
- **true** - Returns true if the platform supports badges.
- **false** - Returns false otherwise.

#### Response Example
```json
{
  "example": true
}
```
```

--------------------------------

### Kotlin Singleton for Android Badge Management

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

Singleton object that manages badge updates by detecting and delegating to the appropriate launcher-specific implementation. Handles badge support checks and updates.

```kotlin
object Badge {
    fun isBadgeSupported(context: Context): Boolean { ... }
    fun updateBadge(context: Context, count: Int) { ... }
    fun applyNotification(notification: Notification?) { ... }
    
    private fun updateBadgeOrThrow(context: Context, count: Int) { ... }
    private fun initBadge(context: Context): Boolean { ... }
    
    var notification: Notification? = null
}
```

--------------------------------

### Update Notification Badge Count

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

This Dart function checks if the app badge functionality is supported on macOS and then updates the badge with the provided count. Usage examples show how to display a count or clear the badge.

```dart
import 'package:app_badge_plus/app_badge_plus.dart';

// In a macOS app
void updateNotificationBadge(int count) async {
    if (await AppBadgePlus.isSupported()) {
        await AppBadgePlus.updateBadge(count);
    }
}

// Usage
updateNotificationBadge(5);  // Shows "5" on dock
updateNotificationBadge(0);  // Clears badge
```

--------------------------------

### Check Badge Support

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Checks whether the current device's launcher supports app badges. The first call triggers automatic launcher detection, which is an expensive operation. The result is cached for subsequent calls. Nexus launchers always return false.

```kotlin
fun isBadgeSupported(context: Context): Boolean
```

--------------------------------

### Dart Method Channel App Badge Plus Implementation

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

Default platform implementation using Flutter method channels for native communication. Extends AppBadgePlusPlatform.

```dart
class MethodChannelAppBadgePlus extends AppBadgePlusPlatform {
  final methodChannel = const MethodChannel('app_badge_plus');
  
  @override
  Future<void> updateBadge(int count) async { ... }
  
  @override
  Future<bool> isSupported() async {
    // ...
  }
}
```

--------------------------------

### Check Support and Update Badge

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Checks if the badge functionality is supported on the current platform and updates the badge count if it is. Ensure the `app_badge_plus` package is imported.

```dart
import 'package:app_badge_plus/app_badge_plus.dart';

void updateNotificationBadge(int count) async {
    final isSupported = await AppBadgePlus.isSupported();
    if (isSupported) {
        await AppBadgePlus.updateBadge(count);
    }
}
```

--------------------------------

### Badge

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

A singleton object in the Android implementation that acts as a central manager for badge updates. It detects the current launcher and delegates badge operations to the appropriate `IBadge` implementation.

```APIDOC
## Object: Badge

### Description
Singleton that manages badge updates by detecting and delegating to the appropriate launcher-specific implementation.

### Source
`android/src/main/kotlin/me/liolin/app_badge_plus/badge/Badge.kt`

### Type
Kotlin object (singleton)

### Public Methods
#### `isBadgeSupported(Context context)`
- **Description**: Checks if badge functionality is supported on the current Android device and launcher.
- **Parameters**:
  - **context** (Context) - Required - The Android context.
- **Return Type**: `Boolean`

#### `updateBadge(Context context, int count)`
- **Description**: Updates the app's badge count. This method will attempt to find and use the correct launcher implementation.
- **Parameters**:
  - **context** (Context) - Required - The Android context.
  - **count** (int) - Required - The desired badge count.
- **Return Type**: `Unit`

#### `applyNotification(Notification? notification)`
- **Description**: Applies a notification to be used in conjunction with badge updates, potentially for systems that tie badges to notifications.
- **Parameters**:
  - **notification** (Notification?) - Optional - The notification to apply.
- **Return Type**: `Unit`

### Properties
#### `notification`
- **Description**: An optional `Notification` object that can be used by some badge implementations.
- **Type**: `Notification?`
```

--------------------------------

### Fallback Home Package Constant

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Defines the package name for the Android FallbackHome system activity. This constant is used internally for identifying the FallbackHome.

```kotlin
private const val FALLBACK_HOME_PACKAGE = "com.android.settings"
```

--------------------------------

### Is Supported Flow

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Illustrates the call flow for checking if the app badge is supported from Dart to native code across different platforms.

```Dart
  │
  ├─ AppBadgePlus.isSupported()
  │
  ├─ MethodChannelAppBadgePlus.isSupported()
  │
  └─ methodChannel.invokeMethod('isSupported')
     │
     ├─ Android
     │  └─ AppBadgePlusPlugin.onMethodCall()
     │     └─ Badge.isBadgeSupported(context)
     │        ├─ [First call] Launcher detection
     │        │  ├─ LauncherTool.getLauncherList()
     │        │  └─ Try each badge implementation
     │        └─ result.success(Boolean)
     │
     ├─ iOS
     │  └─ AppBadgePlusPlugin.handle()
     │     └─ result(true)
     │
     └─ macOS
        └─ AppBadgePlusPlugin.handle()
           └─ result(true)

Future<bool> completes with result
```

--------------------------------

### Check Badge Support

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Determines if the native platform and its current configuration support application badge functionality. This is useful for gracefully handling scenarios where badges cannot be displayed.

```APIDOC
## Method: isSupported

### Description
Checks if the current platform and launcher configuration support application badge functionality.

### Method
`isSupported`

### Channel
`app_badge_plus`

### Parameters
None

### Request Example
```dart
final supported = await methodChannel.invokeMethod<bool>('isSupported');
```

### Response
#### Success Response
- **Type**: `bool`
- **Return Values**:
  - `true`: If badges are supported on the platform.
  - `false`: If badges are not supported (e.g., no compatible Android launcher).

### Behavior by Platform
- **Android**: Detects compatible launchers; may take longer on the first call due to detection. Caches the result.
- **iOS**: Always returns `true`.
- **macOS**: Always returns `true`.

### Error Handling
- **Throws**: `PlatformException` (rarely).
```

--------------------------------

### PackageManager Query Flags by API Level

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Selects the appropriate PackageManager query flag based on the Android API level. Use PackageManager.MATCH_ALL for API 23+ and 0 for older versions.

```kotlin
val queryFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    PackageManager.MATCH_ALL
} else {
    0
}
```

--------------------------------

### Abstract isSupported Method

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

Abstract method that must be implemented by subclasses to determine if badge functionality is supported on the current platform. Throws UnimplementedError if not overridden.

```dart
Future<bool> isSupported()
```

--------------------------------

### Solid Launcher Android Manifest Permissions

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

Declares necessary permissions for Solid Launcher to enable badge updates via the app_badge_plus plugin.

```xml
<uses-permission android:name="com.majeur.launcher.permission.UPDATE_BADGE"/>
```

--------------------------------

### Declare Launcher Permissions (Android)

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Declare necessary permissions in `AndroidManifest.xml` for specific launchers like Samsung and Huawei to allow badge updates.

```xml
<!-- Samsung -->
<uses-permission android:name="com.sec.android.provider.badge.permission.WRITE"/>

<!-- Huawei -->
<uses-permission android:name="com.huawei.android.launcher.permission.CHANGE_BADGE"/>
```

--------------------------------

### Direct Usage in Dart

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

The AppBadgePlus class has only static methods and does not require constructor options for direct usage.

```dart
await AppBadgePlus.updateBadge(5);
```

--------------------------------

### Badge.isBadgeSupported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_badge.md

Checks if the current device's launcher supports app badges. This is a static method on the Badge object.

```APIDOC
## isBadgeSupported(context: Context)

### Description
Checks whether the current device's launcher supports app badges.

### Method
Static method

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **context** (Context) - Required - Android application context

### Response
#### Success Response (Boolean)
- **true** if a compatible badge launcher is found, **false** otherwise

### Example
```kotlin
val isSupported = Badge.isBadgeSupported(context)
if (isSupported) {
    Badge.updateBadge(context, 5)
}
```
```

--------------------------------

### Check Badge Support

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Verify if the current device and launcher support the badge functionality provided by AppBadgePlus.

```dart
final supported = await AppBadgePlus.isSupported();
print('Badge supported: $supported');
```

--------------------------------

### Plugin Registration in pubspec.yaml

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

Configure the App Badge Plus plugin for Android by defining its package and plugin class in your pubspec.yaml file. This is essential for the plugin to be registered correctly.

```yaml
flutter:
  plugin:
    platforms:
      android:
        package: me.liolin.app_badge_plus
        pluginClass: AppBadgePlusPlugin
```

--------------------------------

### MethodChannelAppBadgePlus Instance and Method Channel

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

Initializes the MethodChannelAppBadgePlus and defines the specific method channel ('app_badge_plus') used for native communication.

```dart
final methodChannel = const MethodChannel('app_badge_plus')
```

--------------------------------

### macOS Plugin Configuration in pubspec.yaml

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

Specifies the plugin class for the App Badge Plus Flutter plugin on macOS.

```yaml
flutter:
  plugin:
    platforms:
      macos:
        pluginClass: AppBadgePlusPlugin
```

--------------------------------

### Manually Setting Platform Implementation in Dart

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

Allows setting a custom implementation for the App Badge Plus platform interface, useful for testing. The default implementation is MethodChannelAppBadgePlus().

```dart
import 'package:app_badge_plus/app_badge_plus_platform_interface.dart';

// Set custom implementation for testing
AppBadgePlusPlatform.instance = CustomBadgeImplementation();

// Get current implementation
final implementation = AppBadgePlusPlatform.instance;
```

--------------------------------

### Handle Is Supported Method Call

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/ios_plugin.md

Handles the 'isSupported' method call. Always returns true for iOS as app badges are always supported.

```swift
result(true)
```

--------------------------------

### View Android Badge Logs

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Command to filter Android logs for messages tagged with 'Badge'.

```bash
adb logcat Badge:V
```

--------------------------------

### Recover from Android Errors with PlatformException Handling

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Implement robust error handling for Android by first checking if badges are supported. If an unexpected PlatformException occurs, attempt a retry strategy with exponential backoff.

```dart
try {
    final supported = await AppBadgePlus.isSupported();
    if (supported) {
        await AppBadgePlus.updateBadge(count);
    } else {
        print('Badge not supported on this device');
    }
} on PlatformException catch (e) {
    print('Unexpected error: ${e.message}');
    // Attempt retry with exponential backoff
}
```

--------------------------------

### isSupported Method

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/ios_plugin.md

Checks if the app badge functionality is supported on the current iOS device. This method is called from Dart and executed on the native iOS side.

```APIDOC
## isSupported Method

### Description
Checks if the app badge functionality is supported on the current iOS device. This method is called from Dart and executed on the native iOS side.

### Method
POST (via Method Channel)

### Endpoint
`app_badge_plus` (Method Channel Name)

### Parameters
#### Arguments
None

### Request Example
```dart
final supported = await channel.invokeMethod<bool>('isSupported');
```

### Response
#### Success Response (true)
- **Boolean** (true) - Indicates that app badges are always supported on iOS.

### Behavior:
Returns `true` for all iOS versions as app badges are a standard feature.
```

--------------------------------

### IBadge

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

Interface for all Android badge implementations. It defines the contract for updating badges and retrieving a list of supported launchers, ensuring consistency across different Android launcher types.

```APIDOC
## Interface: IBadge

### Description
Interface that all Android badge implementations must implement. Defines the contract for launcher-specific badge operations.

### Source
`android/src/main/kotlin/me/liolin/app_badge_plus/badge/IBadge.kt`

### Methods
#### `updateBadge(Context context, int count)`
- **Description**: Updates the badge count for the application within the given context.
- **Parameters**:
  - **context** (Context) - Required - The Android context.
  - **count** (int) - Required - The new badge count.
- **Return Type**: `void`

#### `getSupportLaunchers()`
- **Description**: Returns a list of package names for launchers that this implementation supports.
- **Return Type**: `List<String>`
```

--------------------------------

### AppBadgePlusPlatform Constructor

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

The protected constructor for the abstract AppBadgePlusPlatform class. It is intended for use by subclasses only.

```dart
AppBadgePlusPlatform()
```

--------------------------------

### AppBadgePlusPlugin onMethodCall - isSupported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

Handles the 'isSupported' method call from Dart. It checks if badge functionality is supported on the device.

```kotlin
val isSupported = Badge.isBadgeSupported(context)
result.success(isSupported)
```

--------------------------------

### Handle Platform Exceptions

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/README.md

Wrap badge update calls in a `try-catch` block to handle potential `PlatformException` errors, especially on Android.

```dart
try {
    await AppBadgePlus.updateBadge(5);
} on PlatformException catch (e) {
    print('Error: ${e.message}');
}
```

--------------------------------

### Rearrange Launcher List

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Rearranges a mutable list of ResolveInfo objects to place the default launcher at the beginning of the list. This is an internal utility function used to ensure the default launcher is prioritized.

```kotlin
val launchComponent = getComponentName(context)
return launchComponent?.className ?: ""
```

--------------------------------

### Android Launcher Detection Mechanisms

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/README.md

Details the various methods Android uses to display app badges, including native notification badges and specific implementations for popular launchers like Samsung and Xiaomi.

```plaintext
1. Android 8.0+ Native Badges (default) — Uses notification badges
2. Samsung Launcher — Broadcasts intent android.intent.action.BADGE_COUNT_UPDATE
3. Xiaomi MIUI — Uses reflection to set notification extra fields
4. Huawei Launcher — Proprietary API calls
5. Other Launchers — Sony, HTC, OPPO, Vivo, etc. (manufacturer-specific)
```

--------------------------------

### macOS Method Channel Handler

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Swift code for handling method channel calls on macOS within the AppBadgePlusPlugin.

```swift
switch call.method {
case "updateBadge":
    let args = call.arguments as? Dictionary<String, Any>
    let count = (args?["count"] as? Int) ?? 0
    DispatchQueue.main.async {
        if count > 0 {
            NSApplication.shared.dockTile.badgeLabel = "\(count)"
        } else {
            NSApplication.shared.dockTile.badgeLabel = nil
        }
    }
    result(nil)

case "isSupported":
    result(true)

default:
    result(FlutterMethodNotImplemented)
}
```

--------------------------------

### AppBadgePlusPlugin Lifecycle Methods

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

Details the lifecycle methods of the AppBadgePlusPlugin, which are essential for its integration with the Flutter engine and handling method calls.

```APIDOC
## AppBadgePlusPlugin Lifecycle

### `onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding)`

**Description:** Called when the plugin is attached to the Flutter engine. It sets up the method channel and stores the application context.

**Parameters:**
- `flutterPluginBinding` (FlutterPlugin.FlutterPluginBinding) - Required - Plugin binding with engine access.

**Behavior:**
- Creates MethodChannel with name `"app_badge_plus"`.
- Sets this plugin instance as the method call handler.
- Stores application context for badge operations.

### `onMethodCall(call: MethodCall, result: Result)`

**Description:** Handles incoming method calls from the Dart side and routes them to the appropriate native badge operations.

**Parameters:**
- `call` (MethodCall) - Required - Method call with method name and arguments.
- `result` (Result) - Required - Callback to send response back to Dart.

**Supported Methods:**

#### `updateBadge`

- **Arguments:** `Map<String, Any>` with `"count"` (Int) key.
- **Behavior:** Calls `Badge.updateBadge(context, count)`.
- **Response:** null (void).

#### `isSupported`

- **Arguments:** None.
- **Behavior:** Calls `Badge.isBadgeSupported(context)`.
- **Response:** Boolean.

#### Unknown Method

- **Behavior:** Returns `notImplemented()` error.

### `onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding)`

**Description:** Called when the plugin is detached from the Flutter engine. It cleans up resources by removing the method call handler and clearing the context reference.

**Parameters:**
- `binding` (FlutterPlugin.FlutterPluginBinding) - Required - Plugin binding.

**Behavior:**
- Removes method call handler.
- Clears context reference.
```

--------------------------------

### Apex Launcher Android Manifest Permissions

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

Declares necessary permissions for Apex Launcher to enable badge updates via the app_badge_plus plugin.

```xml
<uses-permission android:name="com.anddoes.launcher.permission.UPDATE_COUNT"/>
```

--------------------------------

### Check if App Badges are Supported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/README.md

Use AppBadgePlus.isSupported() to determine if the current launcher environment supports app badges. It always returns true on iOS.

```dart
AppBadgePlus.isSupported();
```

--------------------------------

### Kotlin Interface for Android Badge Implementations

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

Interface that all Android badge implementations must implement. Defines the contract for launcher-specific badge operations.

```kotlin
interface IBadge {
    fun updateBadge(context: Context, count: Int)
    fun getSupportLaunchers(): List<String>
}
```

--------------------------------

### Requesting Notification Permission on iOS

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

It is recommended to request notification permission in the `initState()` method for iOS. This ensures badges are displayed correctly.

```dart
import 'package:permission_handler/permission_handler.dart';

void requestPermission() async {
    final status = await Permission.notification.request();
    if (status.isGranted) {
        print('Notification permission granted');
    }
}
```

--------------------------------

### Abstract updateBadge Method

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

Abstract method that must be implemented by subclasses to handle the actual badge count update. Throws UnimplementedError if not overridden.

```dart
Future<void> updateBadge(int count)
```

--------------------------------

### Check if Badges Are Supported

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/README.md

This method checks if the current device and platform support application badges. It returns a boolean value indicating support.

```APIDOC
## Check if Badges Are Supported

### Description
Checks if the current device and platform support application badges. This is useful for conditionally displaying badge-related features.

### Method
`isSupported()`

### Returns
- `Future<bool>`: A future that resolves to `true` if badges are supported, `false` otherwise.

### Example
```dart
import 'package:app_badge_plus/app_badge_plus.dart';

final supported = await AppBadgePlus.isSupported();
if (supported) {
    print('Badges are supported on this device');
}
```
```

--------------------------------

### Dispatch to Main Thread

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/ios_plugin.md

Ensures thread-safe interaction with UIApplication and UNUserNotificationCenter by dispatching badge update operations to the main thread.

```swift
DispatchQueue.main.async {
    // Badge update code
}
```

--------------------------------

### iOS Plugin Configuration in pubspec.yaml

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/configuration.md

Specifies the plugin class for the App Badge Plus Flutter plugin on iOS.

```yaml
flutter:
  plugin:
    platforms:
      ios:
        pluginClass: AppBadgePlusPlugin
```

--------------------------------

### AppBadgePlusPlatform

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

The abstract base class for all platform-specific badge implementations. It defines the core API for updating badges and checking support, extending Flutter's PlatformInterface for robust cross-platform compatibility.

```APIDOC
## Class: AppBadgePlusPlatform

### Description
Abstract base class for platform-specific badge implementations. Extends Flutter's PlatformInterface for safe polymorphism across platform channels.

### Source
`lib/app_badge_plus_platform_interface.dart`

### Methods
#### `updateBadge(int count)`
- **Description**: Updates the badge count on the app icon.
- **Return Type**: `Future<void>`

#### `isSupported()`
- **Description**: Checks if the platform supports badge updates.
- **Return Type**: `Future<bool>`

### Properties
#### `instance` (getter/setter)
- **Description**: Accesses the current platform-specific implementation of `AppBadgePlusPlatform`. Allows for setting a custom implementation.
- **Type**: `AppBadgePlusPlatform`
```

--------------------------------

### Is Supported Protocol Request Format

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Shows the JSON request format sent from Dart to native code for the isSupported method.

```json
{
    "method": "isSupported",
    "args": null
}
```

--------------------------------

### Sony Android Manifest Permissions

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_plugin.md

Declares necessary permissions for Sony devices to enable badge updates via the app_badge_plus plugin.

```xml
<uses-permission android:name="com.sonyericsson.home.permission.BROADCAST_BADGE"/>
<uses-permission android:name="com.sonymobile.home.permission.PROVIDER_INSERT_BADGE"/>
```

--------------------------------

### Method Channel Protocol

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

Details the native method calls used for communication between the Flutter plugin and native code, including method names, arguments, and expected return types.

```APIDOC
## Method Channel Protocol

### Native Method Calls

The plugin communicates with native code through method channels using these method names and arguments:

**updateBadge**

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| count | int | Yes | The badge count to display |

Expected return: null (void)

**isSupported**

No arguments.

Expected return: boolean indicating platform support
```

--------------------------------

### Update Badge Method Channel Arguments

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/types.md

Defines the arguments expected for the `updateBadge` method channel call. This map includes the badge count to be set.

```dart
Map<String, dynamic> {
  "count": int
}
```

--------------------------------

### AppBadgePlusPlatform

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/app_badge_plus_platform_interface.md

The abstract platform interface for AppBadgePlus, defining the contract for badge operations. Implementations must override `updateBadge` and `isSupported`.

```APIDOC
## AppBadgePlusPlatform

**Import:** `package:app_badge_plus/app_badge_plus_platform_interface.dart`

Abstract class that defines the platform interface for badge operations.

### Constructor

```dart
AppBadgePlusPlatform()
```

Constructs an AppBadgePlusPlatform instance. Protected constructor called only by subclasses.

---

### Static Properties

#### instance

```dart
static AppBadgePlusPlatform get instance
static set instance(AppBadgePlusPlatform instance)
```

Gets or sets the current platform implementation instance. Used internally to swap platform implementations.

**Type:** `AppBadgePlusPlatform`

**Default:** `MethodChannelAppBadgePlus()` instance

**Usage:**

```dart
// Get the current implementation
AppBadgePlusPlatform implementation = AppBadgePlusPlatform.instance;

// Set a custom implementation for testing
AppBadgePlusPlatform.instance = CustomBadgeImplementation();
```

---

### Abstract Methods

#### updateBadge()

```dart
Future<void> updateBadge(int count)
```

Abstract method that platform implementations must override to update the badge count.

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| count | int | Yes | Badge count to display (0 to remove) |

**Return Type:** `Future<void>`

**Throws:** `UnimplementedError` in the base class if not overridden.

---

#### isSupported()

```dart
Future<bool> isSupported()
```

Abstract method that platform implementations must override to check badge support.

**Return Type:** `Future<bool>` — true if badges are supported, false otherwise

**Throws:** `UnimplementedError` in the base class if not overridden.
```

--------------------------------

### Handle Errors When Checking Badge Support

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Use a try-catch block when calling 'isSupported' to gracefully handle potential PlatformExceptions. If an error occurs, it's often assumed that badges are not supported.

```dart
try {
    final supported = await AppBadgePlus.isSupported();
    print('Supported: $supported');
} catch (e) {
    print('Failed to check badge support: $e');
    // Assume not supported on error
}
```

--------------------------------

### Android BadgeException Constructors

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/errors.md

Use these constructors to create BadgeException instances in native Android code. The first takes a simple message, while the second includes an original exception for cause chaining.

```kotlin
// Simple message
BadgeException("No default launcher available")

// With cause chain
BadgeException("Unable to update badge", originalException)
```

--------------------------------

### Handle Unknown Method Call

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/ios_plugin.md

Handles any method calls not explicitly implemented by returning FlutterMethodNotImplemented.

```swift
result(FlutterMethodNotImplemented)
```

--------------------------------

### Is Supported Protocol Response Format

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Shows the JSON response format sent from native code back to Dart for the isSupported method.

```json
{
    "result": true
}
```

--------------------------------

### Handle Update Badge Method Call

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/macos_plugin.md

Handles the 'updateBadge' method call from Flutter. It extracts the count, updates the dock tile badge label on the main thread, and returns nil.

```swift
let args = call.arguments as? Dictionary<String, Any>
let count = (args?["count"] as? Int) ?? 0
DispatchQueue.main.async {
    if count > 0 {
        NSApplication.shared.dockTile.badgeLabel = "\(count)"
    } else {
        NSApplication.shared.dockTile.badgeLabel = nil
    }
}
result(nil)
```

--------------------------------

### Handle Platform Exceptions for Badge Update

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/endpoints.md

Wrap calls to 'updateBadge' in a try-catch block to handle potential PlatformExceptions. Android implementation typically logs errors rather than throwing them.

```dart
try {
    await methodChannel.invokeMethod<void>('updateBadge', {'count': 5});
} on PlatformException catch (e) {
    print('Error: ${e.code} - ${e.message}');
}
```

--------------------------------

### Fallback Home Class Constant

Source: https://github.com/windows7lake/app_badge_plus/blob/main/_autodocs/api-reference/android_utilities.md

Defines the class name for the Android FallbackHome system activity. This constant is used internally for identifying the FallbackHome.

```kotlin
private const val FALLBACK_HOME_CLASS = "com.android.settings.FallbackHome"
```
Tokens:
Raw