android-notify 1.3__py3-none-any.whl → 1.60.6.dev0__py3-none-any.whl

android_notify/sword.py

@@ -1,375 +1,1192 @@
 """This Module Contain Class for creating Notification With Java"""
-import difflib
-import random
-import os
-import re
-from jnius import autoclass,cast  # pylint: disable=W0611, C0114
-
-DEV=0
-ON_ANDROID = False
-
-try:
-    # Get the required Java classes
-    PythonActivity = autoclass('org.kivy.android.PythonActivity')
-    String = autoclass('java.lang.String')
-    Intent = autoclass('android.content.Intent')
-    PendingIntent = autoclass('android.app.PendingIntent')
-    context = PythonActivity.mActivity # Get the app's context
-    BitmapFactory = autoclass('android.graphics.BitmapFactory')
-    BuildVersion = autoclass('android.os.Build$VERSION')
-    NotificationManager = autoclass('android.app.NotificationManager')
-    NotificationChannel = autoclass('android.app.NotificationChannel')
-    ON_ANDROID = True
-except Exception as e:# pylint: disable=W0718
-    MESSAGE='This Package Only Runs on Android !!! ---> Check "https://github.com/Fector101/android_notify/" to see design patterns and more info.' # pylint: disable=C0301
-    print(MESSAGE if DEV else '')
-
-if ON_ANDROID:
-    try:
-        from android.permissions import request_permissions, Permission,check_permission # pylint: disable=E0401
-        from android.storage import app_storage_path  # pylint: disable=E0401
-
-        NotificationManagerCompat = autoclass('androidx.core.app.NotificationManagerCompat')
-        NotificationCompat = autoclass('androidx.core.app.NotificationCompat')
-
-        # Notification Design
-        NotificationCompatBuilder = autoclass('androidx.core.app.NotificationCompat$Builder') # pylint: disable=C0301
-        NotificationCompatBigTextStyle = autoclass('androidx.core.app.NotificationCompat$BigTextStyle') # pylint: disable=C0301
-        NotificationCompatBigPictureStyle = autoclass('androidx.core.app.NotificationCompat$BigPictureStyle') # pylint: disable=C0301
-        NotificationCompatInboxStyle = autoclass('androidx.core.app.NotificationCompat$InboxStyle')
-    except Exception as e:# pylint: disable=W0718
-        print(e if DEV else '','Import Fector101')
-        # print(e if DEV else '')
-        print("""
-        Dependency Error: Add the following in buildozer.spec:
-        * android.gradle_dependencies = androidx.core:core-ktx:1.15.0, androidx.core:core:1.6.0
-        * android.enable_androidx = True
-        * android.permissions = POST_NOTIFICATIONS
-        """)
-
-class Notification:
+import os, time, threading, traceback
+from typing import Any, Callable
+from .config import cast, autoclass
+
+from .an_types import Importance
+from .an_utils import can_accept_arguments, get_python_activity_context, \
+    get_android_importance, generate_channel_id, get_img_from_path, setLayoutText, \
+    get_bitmap_from_url, add_data_to_intent, get_sound_uri, icon_finder, get_bitmap_from_path, \
+    can_show_permission_request_popup, open_settings_screen
+
+from .config import from_service_file, get_python_activity, get_notification_manager, ON_ANDROID, on_flet_app, get_package_name
+from .config import (Bundle, String, BuildVersion,
+                     Intent, PendingIntent,
+                     app_storage_path,
+                     NotificationChannel, RemoteViews,
+                     run_on_ui_thread,
+                     )
+from .config import (AndroidNotification, NotificationCompatBuilder,
+                     NotificationCompatBigTextStyle, NotificationCompatBigPictureStyle,
+                     NotificationCompatInboxStyle,
+                     Color, Manifest
+                     )
+from .styles import NotificationStyles
+from .base import BaseNotification
+
+DEV = 0
+PythonActivity = get_python_activity()
+context = get_python_activity_context()
+
+
+class Notification(BaseNotification):
     """
     Send a notification on Android.
 
     :param title: Title of the notification.
     :param message: Message body.
-    :param style: Style of the notification 
-    ('simple', 'progress', 'big_text', 'inbox', 'big_picture', 'large_icon', 'both_imgs').
-    both_imgs == using lager icon and big picture
-    :param big_picture_path: Path to the image resource.
-    :param large_icon_path: Path to the image resource.
+    ---
+    (Style Options)
+    :param style: Style of the notification ('simple', 'progress', 'big_text', 'inbox', 'big_picture', 'large_icon', 'both_imgs'). both_imgs == using lager icon and big picture
+    :param big_picture_path: Relative Path to the image resource.
+    :param large_icon_path: Relative Path to the image resource.
+    :param progress_current_value: Integer To set progress bar current value.
+    :param progress_max_value: Integer To set Max range for progress bar.
+    :param body: Large text For `big_Text` style, while `message` acts as subtitle.
+    :param lines_txt: text separated by newLine symbol For `inbox` style `use addLine method instead`
     ---
     (Advance Options)
-    :param channel_name: Defaults to "Default Channel"
-    :param channel_id: Defaults to "default_channel"
+    :param sub_text: str for additional information next to title
+    :param id: Pass in Old 'id' to use old instance
+    :param callback: Function for notification Click.
+    :param channel_name: - str Defaults to "Default Channel"
+    :param channel_id: - str Defaults to "default_channel"
     ---
     (Options during Dev On PC)
-    :param logs: Defaults to True
+    :param logs: - Bool Defaults to True
+    ---
+    (Custom Style Options)
+    :param title_color: title color str (to be safe use hex code)
+    :param message_color: message color str (to be safe use hex code)
+
     """
-    notification_ids=[]
-    style_values=[
-                  '','simple',
-                  'progress','big_text',
-                  'inbox', 'big_picture',
-                  'large_icon','both_imgs',
-                  'custom'
-                ] # TODO make pattern for non-android Notifications
-    defaults={
-        'title':'Default Title',
-        'message':'Default Message', # TODO Might change message para to list if style set to inbox
-        'style':'simple',
-        'big_picture_path':'',
-        'large_icon_path':'',
-        'progress_max_value': 100,
-        'progress_current_value': 0,
-        'channel_name':'Default Channel',
-        'channel_id':'default_channel',
-        'logs':True,
-    }
+
+    notification_ids = [0]
+    btns_box = {}
+    main_functions = {}
+    passed_check = False
+
     # During Development (When running on PC)
-    logs=not ON_ANDROID
-    def __init__(self,**kwargs):
-        self.__validateArgs(kwargs)
-        # Basic options
-        self.title=''
-        self.message=''
-        self.style=''
-        self.large_icon_path=''
-        self.big_picture_path=''
-        self.progress_current_value=0
-        self.progress_max_value=100
-        # Advance Options
-        self.channel_name=''
-        self.channel_id=''
-        self.silent=False
-        # During Dev on PC
-        self.logs=self.logs
-        # Private (Don't Touch)
-        self.__id = self.__getUniqueID()
-        self.__setArgs(kwargs)
-        self.__builder=None
+    BaseNotification.logs = not ON_ANDROID
+
+    def __init__(self, **kwargs):  # @dataclass already does work
+        super().__init__(**kwargs)
+
+        self.__id = self.id or self.__get_unique_id()  # Different use from self.name all notifications require `integers` id's not `strings`
+        self.id = self.__id  # To use same Notification in different instances
+
+        # To Track progressbar last update (According to Android Docs Don't update bar to often, I also faced so issues when doing that)
+        self.__update_timer = None
+        self.__progress_bar_msg = ''
+        self.__progress_bar_title = ''
+        self.__cooldown = 0
+
+        self.__built_parameter_filled = False
+        self.__using_set_priority_method = False
+
+        # For components
+        self.__lines = []
+        self.__has_small_icon = False  # important notification can't send without
+        self.__using_custom = self.message_color or self.title_color
+        self.__format_channel(self.channel_name, self.channel_id)
+        self.__builder = None  # available through getter `self.builder`
+        self.__no_of_buttons = 0
+        self.notification_manager = None
+
         if not ON_ANDROID:
             return
-        # TODO make send method wait for __asks_permission_if_needed method
-        self.__asks_permission_if_needed()
-        self.notification_manager = context.getSystemService(context.NOTIFICATION_SERVICE)
 
-    def updateTitle(self,new_title):
+        if not from_service_file() and not NotificationHandler.has_permission():
+            NotificationHandler.asks_permission()
+
+        self.notification_manager = get_notification_manager()
+        self.__builder = NotificationCompatBuilder(context, self.channel_id)
+
+    def addLine(self, text: str):
+        self.__lines.append(text)
+
+    def cancel(self, _id=0):
+        """
+        Removes a Notification instance from tray
+        :param _id: not required uses Notification instance id as default
+        """
+        if ON_ANDROID:
+            self.notification_manager.cancel(_id or self.__id)
+        if self.logs:
+            print('Removed Notification.')
+
+    @classmethod
+    def cancelAll(cls):
+        """
+        Removes all app Notifications from tray
+        """
+        if ON_ANDROID:
+            get_notification_manager().cancelAll()
+        if cls.logs:
+            print('Removed All Notifications.')
+
+    @classmethod
+    def channelExists(cls, channel_id):
+        """
+        Checks if a notification channel exists
+        """
+        if not ON_ANDROID:
+            return False
+        notification_manager = get_notification_manager()
+        if BuildVersion.SDK_INT >= 26 and notification_manager.getNotificationChannel(channel_id):
+            return True
+        return False
+
+    @classmethod
+    def createChannel(cls, id, name: str, description='', importance: Importance = 'urgent', res_sound_name=None):
+        """
+        Creates a user visible toggle button for specific notifications, Required For Android 8.0+
+        :param id: Used to send other notifications later through same channel.
+        :param name: user-visible channel name.
+        :param description: user-visible detail about channel (Not required defaults to empty str).
+        :param importance: ['urgent', 'high', 'medium', 'low', 'none'] defaults to 'urgent' i.e. makes a sound and shows briefly
+        :param res_sound_name: audio file file name (without .wav or .mp3) locate in res/raw/
+        :return: boolean if channel created
+        """
+
+        if not ON_ANDROID:
+            return False
+
+        notification_manager = get_notification_manager()
+        android_importance_value = get_android_importance(importance)
+        sound_uri = get_sound_uri(res_sound_name)
+
+        if not cls.channelExists(id):
+            channel = NotificationChannel(id, name, android_importance_value)
+            if description:
+                channel.setDescription(description)
+            if sound_uri:
+                channel.setSound(sound_uri, None)
+            notification_manager.createNotificationChannel(channel)
+            return True
+        return False
+
+    @classmethod
+    def deleteChannel(cls, channel_id):
+        """Delete a Channel Matching channel_id"""
+        if not ON_ANDROID:
+            return None
+
+        if cls.channelExists(channel_id):
+            get_notification_manager().deleteNotificationChannel(channel_id)
+
+    @classmethod
+    def deleteAllChannel(cls):
+        """Deletes all notification channel
+        :returns amount deleted
+        """
+
+        amount = 0
+        if not ON_ANDROID:
+            return amount
+
+        notification_manager = get_notification_manager()
+        channels = cls.getChannels()
+        for index in range(channels.size()):
+            amount += 1
+            channel = channels.get(index)
+            channel_id = channel.getId()
+            notification_manager.deleteNotificationChannel(channel_id)
+        return amount
+
+    @classmethod
+    def doChannelsExist(cls, ids):
+        """Uses list of IDs to check if channel exists
+        returns list of channels that don't exist
+        """
+        if not ON_ANDROID:
+            return ids  # Assume none exist on non-Android environments
+        missing_channels = []
+        notification_manager = get_notification_manager()
+        for channel_id in ids:
+            exists = (
+                    BuildVersion.SDK_INT >= 26 and
+                    notification_manager.getNotificationChannel(channel_id)
+            )
+            if not exists:
+                missing_channels.append(channel_id)
+        return missing_channels
+
+    def refresh(self):
+        """TO apply new components on notification"""
+        if self.__built_parameter_filled:
+            # Don't dispatch before filling required values `self.__create_basic_notification`
+            # We generally shouldn't dispatch till user call .send()
+            self.__applyNewLinesIfAny()
+            self.__dispatch_notification()
+
+    def setBigPicture(self, path):
+        """
+        set a Big Picture at the bottom
+        :param path: can be `Relative Path` or `URL`
+        :return:
+        """
+        if ON_ANDROID:
+            self.__build_img(path, NotificationStyles.BIG_PICTURE)
+        elif self.logs:
+            # When on android there are other logs
+            print('Done setting big picture')
+
+    def setSmallIcon(self, path):
+        """
+        sets small icon to the top left
+        :param path: can be `Relative Path` or `URL`
+        :return:
+        """
+        if ON_ANDROID:
+            self.app_icon = path
+            self.__insert_app_icon(path)
+        if self.logs:
+            # When on android there are other logs
+            print('Done setting small icon')
+
+    def setLargeIcon(self, path):
+        """
+        sets Large icon to the right
+        :param path: can be `Relative Path` or `URL`
+        :return:
+        """
+        if ON_ANDROID:
+            self.__build_img(path, NotificationStyles.LARGE_ICON)
+        elif self.logs:
+            # When on android there are other logs
+            print('Done setting large icon')
+
+    def setBigText(self, body, title="", summary=""):
+        """Sets a big text for when drop down button is pressed
+
+        :param body: The big text that will be displayed
+        :param title: The big text title
+        :param summary: The big text summary
+        """
+        if ON_ANDROID:
+            big_text_style = NotificationCompatBigTextStyle()
+            if title:
+                big_text_style.setBigContentTitle(str(title))
+            if summary:
+                big_text_style.setSummaryText(str(summary))
+
+            big_text_style.bigText(str(body))
+            self.__builder.setStyle(big_text_style)
+        elif self.logs:
+            # When on android, there are other logs
+            print('Done setting big text')
+
+    def setSubText(self, text):
+        """
+        In android version 7+ text displays in header next to title,
+        While in lesser versions displays in third line of text, where progress-bar occupies
+        :param text: str for subtext
+
+        """
+        self.sub_text = str(text)
+        if self.logs:
+            print(f'new notification sub text: {self.sub_text}')
+        if ON_ANDROID:
+            self.__builder.setSubText(self.sub_text)
+
+    def setColor(self, color: str):
+        """
+        Sets Notification accent color, visible change in SmallIcon color
+        :param color:  str - red,pink,... (to be safe use hex code)
+        """
+        if self.logs:
+            print(f'new notification icon color: {color}')
+        if ON_ANDROID:
+            self.__builder.setColor(Color.parseColor(color))
+
+    def setWhen(self, secs_ago):
+        """
+        Sets the notification's timestamp to a specified number of seconds in the past.
+
+        Parameters
+        ----------
+        secs_ago : int or float
+            The number of seconds ago the notification should appear to have been posted.
+            For example, `60` means "1 minute ago", `3600` means "1 hour ago".
+
+        Notes
+        -----
+        - Android expects the `when` timestamp in **milliseconds** since the Unix epoch.
+        """
+
+        if ON_ANDROID:
+            ms = int((time.time() - secs_ago) * 1000)
+            self.__builder.setWhen(ms)
+            self.__builder.setShowWhen(True)
+        if self.logs:
+            print(f"Done setting secs ago {secs_ago}")
+
+    def showInfiniteProgressBar(self):
+        """Displays an (Infinite) progress Bar in Notification, that continues loading indefinitely.
+        Can be Removed By `removeProgressBar` Method
+        """
+        if self.logs:
+            print('Showing infinite progressbar')
+        if ON_ANDROID:
+            self.__builder.setProgress(0, 0, True)
+            self.refresh()
+
+    def updateTitle(self, new_title):
         """Changes Old Title
 
         Args:
             new_title (str): New Notification Title
         """
-        self.title=new_title
+        self.title = str(new_title)
+        if self.logs:
+            print(f'new notification title: {self.title}')
         if ON_ANDROID:
-            self.__builder.setContentTitle(new_title)
+            if self.isUsingCustom():
+                self.__apply_basic_custom_style()
+            else:
+                self.__builder.setContentTitle(String(self.title))
+            self.refresh()
 
-    def updateMessage(self,new_message):
+    def updateMessage(self, new_message):
         """Changes Old Message
 
         Args:
             new_message (str): New Notification Message
         """
-        self.message=new_message
+        self.message = str(new_message)
+        if self.logs:
+            print(f'new notification message: {self.message}')
+        if ON_ANDROID:
+            if self.isUsingCustom():
+                self.__apply_basic_custom_style()
+            else:
+                self.__builder.setContentText(String(self.message))
+            self.refresh()
+
+    def updateProgressBar(self, current_value: int, message: str = '', title: str = '', cooldown=0.5,
+                          _callback: Callable = None):
+        """Updates progress bar current value
+
+        Args:
+            current_value (int): the value from progressbar current progress
+            message (str): defaults to last message
+            title (str): defaults to last title
+            cooldown (float, optional): Little Time to Wait before change actually reflects, to avoid android Ignoring Change, Defaults to 0.5secs
+            _callback (object): function for when change actual happens
+
+        NOTE: There is a 0.5 sec delay for value change, if updating title,msg with progressbar frequently pass them in too to avoid update issues
+        """
+
+        # replacing new values for when timer is called
+        self.progress_current_value = current_value
+        self.__progress_bar_msg = message or self.message
+        self.__progress_bar_title = title or self.title
+
+        if self.__update_timer and self.__update_timer.is_alive():
+            # Make Logs too Dirty
+            # if self.logs:
+                # remaining = self.__cooldown - (time.time() - self.__timer_start_time)
+                # print(f'Progressbar update too soon, waiting for cooldown ({max(0, remaining):.2f}s)')
+            return
+
+        def delayed_update():
+            if self.__update_timer is None:  # Ensure we are not executing an old timer
+                if self.logs:
+                    print('ProgressBar update skipped: bar has been removed.')
+                return
+            if self.logs:
+                print(f'Progress Bar Update value: {self.progress_current_value}')
+
+            if _callback:
+                try:
+                    _callback()
+                except Exception as passed_in_callback_error:
+                    print('Exception passed_in_callback_error:', passed_in_callback_error)
+                    traceback.print_exc()
+
+            if not ON_ANDROID:
+                self.__update_timer = None
+                return
+
+            self.__builder.setProgress(self.progress_max_value, self.progress_current_value, False)
+
+            if self.__progress_bar_msg:
+                self.updateMessage(self.__progress_bar_msg)
+            if self.__progress_bar_title:
+                self.updateTitle(self.__progress_bar_title)
+
+            self.refresh()
+            self.__update_timer = None
+
+        # Start a new timer that runs after 0.5 seconds
+        # self.__timer_start_time = time.time() # for logs
+        self.__cooldown = cooldown
+        self.__update_timer = threading.Timer(cooldown, delayed_update)
+        self.__update_timer.start()
+
+    def removeProgressBar(self, message='', show_on_update=True, title: str = '', cooldown=0.5,
+                          _callback: Callable = None):
+        """Removes Progress Bar from Notification
+
+        Args:
+            message (str, optional): notification message. Defaults to 'last message'.
+            show_on_update (bool, optional): To show notification briefly when progressbar removed. Defaults to True.
+            title (str, optional): notification title. Defaults to 'last title'.
+            cooldown (float, optional): Little Time to Wait before change actually reflects, to avoid android Ignoring Change, Defaults to 0.5secs
+            _callback (object): function for when change actual happens
+
+        In-Built Delay of 0.5 sec According to Android Docs Don't Update Progressbar too Frequently
+        """
+
+        # To Cancel any queued timer from `updateProgressBar` method and to avoid race effect incase it somehow gets called while in this method
+        # Avoiding Running `updateProgressBar.delayed_update` at all
+        # so didn't just set `self.__progress_bar_title` and `self.progress_current_value` to 0
+        if self.__update_timer:
+            # Make Logs too Dirty
+            # if self.logs:
+            #     print('cancelled progressbar stream update because about to remove',self.progress_current_value)
+            self.__update_timer.cancel()
+            self.__update_timer = None
+
+        def delayed_update():
+            if self.logs:
+                msg = message or self.message
+                title_ = title or self.title
+                print(f'removed progress bar with message: {msg} and title: {title_}')
+
+            if _callback:
+                try:
+                    _callback()
+                except Exception as passed_in_callback_error:
+                    print('Exception passed_in_callback_error:', passed_in_callback_error)
+                    traceback.print_exc()
+
+            if not ON_ANDROID:
+                return
+
+            if message:
+                self.updateMessage(message)
+            if title:
+                self.updateTitle(title)
+            self.__builder.setOnlyAlertOnce(not show_on_update)
+            self.__builder.setProgress(0, 0, False)
+            self.refresh()
+
+        # Incase `self.updateProgressBar delayed_update` is called right before this method, so android doesn't bounce update
+        threading.Timer(cooldown, delayed_update).start()
+
+    def setPriority(self, importance: Importance):
+        """
+        For devices less than android 8
+        :param importance: ['urgent', 'high', 'medium', 'low', 'none'] defaults to 'urgent' i.e. makes a sound and shows briefly
+        :return:
+        """
+        self.__using_set_priority_method = True
         if ON_ANDROID:
-            self.__builder.setContentText(new_message)
-
-    def updateProgressBar(self,current_value,message:str=''):
-        """message defaults to last message"""
-        self.__builder.setProgress(self.progress_max_value, current_value, False)
-        if message:
-            self.__builder.setContentText(String(message))
-        self.notification_manager.notify(self.__id, self.__builder.build())
-
-    def removeProgressBar(self,message=''):
-        """message defaults to last message"""
-        if message:
-            self.__builder.setContentText(String(message))
-        self.__builder.setProgress(0, 0, False)
-        self.notification_manager.notify(self.__id, self.__builder.build())
-
-    def send(self,silent:bool=False):
+            android_importance_value = get_android_importance(importance)
+            if not isinstance(android_importance_value, str):  # Can be an empty str if importance='none'
+                self.__builder.setPriority(android_importance_value)
+
+    def send(self, silent: bool = False, persistent=False, close_on_click=True):
         """Sends notification
-        
+
         Args:
             silent (bool): True if you don't want to show briefly on screen
+            persistent (bool): True To not remove Notification When User hits clears All notifications button
+            close_on_click (bool): True if you want Notification to be removed when clicked
         """
-        self.silent=self.silent or silent
+        self.silent = silent or self.silent
         if ON_ANDROID:
-            self.__startNotificationBuild()
-            self.notification_manager.notify(self.__id, self.__builder.build())
-        elif self.logs:
-            print(f"""
-    Dev Notification Properties:
-        title: '{self.title}'
-        message: '{self.message}'
-        large_icon_path: '{self.large_icon_path}'
-        big_picture_path: '{self.big_picture_path}'
-        style: '{self.style}'
-        Silent: '{self.silent}'
-    (Won't Print Logs When Complied,except if selected `Notification.logs=True`
-              """)
-            if DEV:
-                print(f'channel_name: {self.channel_name}, Channel ID: {self.channel_id}, id: {self.__id}')
-            print('Can\'t Send Package Only Runs on Android !!! ---> Check "https://github.com/Fector101/android_notify/" for Documentation.\n' if DEV else '\n') # pylint: disable=C0301
-
-    def __validateArgs(self,inputted_kwargs):
-
-        def checkInReference(inputted_keywords,accepteable_inputs,input_type):
-            def singularForm(plural_form):
-                return plural_form[:-1]
-            invalid_args= set(inputted_keywords) - set(accepteable_inputs)
-            if invalid_args:
-                suggestions=[]
-                for arg in invalid_args:
-                    closest_match = difflib.get_close_matches(arg,accepteable_inputs,n=2,cutoff=0.6)
-                    if closest_match:
-                        suggestions.append(f"* '{arg}' Invalid -> Did you mean '{closest_match[0]}'? ") # pylint: disable=C0301
-                    else:
-                        suggestions.append(f"* {arg} is not a valid {singularForm(input_type)}.")
-                suggestion_text='\n'.join(suggestions)
-                hint_msg=singularForm(input_type) if len(invalid_args) < 2 else input_type
-
-                raise ValueError(f"Invalid {hint_msg} provided: \n\t{suggestion_text}\n\t* list of valid {input_type}: [{', '.join(accepteable_inputs)}]")
-
-        allowed_keywords=self.defaults.keys()
-        inputted_keywords_=inputted_kwargs.keys()
-        checkInReference(inputted_keywords_,allowed_keywords,'arguments')
-
-        # Validate style values
-        if 'style' in inputted_keywords_ and inputted_kwargs['style'] not in self.style_values:
-            checkInReference([inputted_kwargs['style']],self.style_values,'values')
-
-    def __setArgs(self,options_dict:dict):
-        for key,value in options_dict.items():
-            if key == 'channel_name':
-                setattr(self,key, value[:40] if value else self.defaults[key])
-            elif key == 'channel_id' and value:
-                setattr(self,key, self.__generate_channel_id(value) if value else self.defaults[key])
-
-            setattr(self,key, value if value else self.defaults[key])
-
-        if "channel_id" not in options_dict and 'channel_name' in options_dict:
-            setattr(self,'channel_id', self.__generate_channel_id(options_dict['channel_name']))
-
-    def __startNotificationBuild(self):
-        self.__createBasicNotification()
-        if self.style not in ['simple','']:
-            self.__addNotificationStyle()
-
-    def __createBasicNotification(self):
-        # Notification Channel (Required for Android 8.0+)
-        if BuildVersion.SDK_INT >= 26 and self.notification_manager.getNotificationChannel(self.channel_id) is None:
-            importance=NotificationManagerCompat.IMPORTANCE_DEFAULT if self.silent else NotificationManagerCompat.IMPORTANCE_HIGH # pylint: disable=possibly-used-before-assignment
-            channel = NotificationChannel(
-                self.channel_id,
-                self.channel_name,
-                importance
+            self.start_building(persistent, close_on_click)
+            self.__dispatch_notification()
+
+        self.__send_logs()
+
+    def send_(self, silent: bool = False, persistent=False, close_on_click=True):
+        """Sends notification without checking for additional notification permission
+
+        Args:
+            silent (bool): True if you don't want to show briefly on screen
+            persistent (bool): True To not remove Notification When User hits clears All notifications button
+            close_on_click (bool): True if you want Notification to be removed when clicked
+        """
+        self.passed_check = True
+        self.send(silent, persistent, close_on_click)
+
+    def __send_logs(self):
+        if not self.logs:
+            return
+        string_to_display = ''
+        print("\n Sent Notification!!!")
+        displayed_args = [
+            "title", "message",
+            "style", "body", "large_icon_path", "big_picture_path",
+            "progress_max_value",
+            'name', "channel_name",
+            ]
+        is_progress_not_default = isinstance(self.progress_current_value, int) or (isinstance(self.progress_current_value, float) and self.progress_current_value != 0.0)
+        for name,value in vars(self).items():
+            if value and name in displayed_args:
+                if name == "progress_max_value":
+                    if is_progress_not_default:
+                        string_to_display += f'\n progress_current_value: {self.progress_current_value}, {name}: {value}'
+                elif name == "channel_name":
+                    string_to_display += f'\n {name}: {value}, channel_id: {self.channel_id}'
+                else:
+                    string_to_display += f'\n {name}: {value}'
+
+        string_to_display += "\n (Won't Print Logs When Complied,except if selected `Notification.logs=True`)"
+        print(string_to_display)
+
+    @property
+    def builder(self):
+        return self.__builder
+
+    def addButton(self, text: str, on_release=None, receiver_name=None, action=None):
+        """For adding action buttons
+
+        :param text: Text For Button
+        :param on_release: function to be called when button is clicked
+        :param receiver_name:  receiver class name
+        :param action: action for receiver
+        """
+
+        if not ON_ANDROID:
+            self.__no_of_buttons += 1
+            return
+
+        # Convert text to CharSequence
+        action_text = cast('java.lang.CharSequence', String(text))
+        action = action or f"{text}_{self.id}"  # tagging with id so it can found notification handle object
+
+        def set_action(action_intent__):
+            action_intent__.setAction(action)
+            action_intent__.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            bundle = Bundle()
+            bundle.putString("title", self.title or 'Title Placeholder')
+            bundle.putInt("key_int", self.__no_of_buttons or 1)
+            action_intent__.putExtras(bundle)
+            action_intent__.putExtra("button_id", action)
+
+        def set_default_action_intent():
+            action_intent__ = Intent(context, PythonActivity)
+            set_action(action_intent__)
+            pending_action_intent__ = PendingIntent.getActivity(
+                context, self.__no_of_buttons or 1, action_intent__,
+                         PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
             )
-            self.notification_manager.createNotificationChannel(channel)
+            return pending_action_intent__
 
-        # Build the notification
-        self.__builder = NotificationCompatBuilder(context, self.channel_id)# pylint: disable=E0606
-        self.__builder.setContentTitle(self.title)
-        self.__builder.setContentText(self.message)
-        self.__builder.setSmallIcon(context.getApplicationInfo().icon)
-        self.__builder.setDefaults(NotificationCompat.DEFAULT_ALL) # pylint: disable=E0606
-        if not self.silent:
-            self.__builder.setPriority(NotificationCompat.PRIORITY_DEFAULT if self.silent else NotificationCompat.PRIORITY_HIGH)
-
-    def __addNotificationStyle(self):
-        # pylint: disable=trailing-whitespace
-        
-        large_icon_javapath=None
-        if self.large_icon_path:
+        if receiver_name:
             try:
-                large_icon_javapath = self.__get_image_uri(self.large_icon_path)
-            except FileNotFoundError as e:
-                print('Failed Adding Big Picture Bitmap: ',e)
-        
-        big_pic_javapath=None
-        if self.big_picture_path:
-            try:
-                big_pic_javapath = self.__get_image_uri(self.big_picture_path)
-            except FileNotFoundError as e:
-                print('Failed Adding Lagre Icon Bitmap: ',e)
-        
-        
-        if self.style == "big_text":
-            big_text_style = NotificationCompatBigTextStyle() # pylint: disable=E0606
-            big_text_style.bigText(self.message)
-            self.__builder.setStyle(big_text_style)
-            
-        elif self.style == "inbox":
-            inbox_style = NotificationCompatInboxStyle() # pylint: disable=E0606
-            for line in self.message.split("\n"):
-                inbox_style.addLine(line)
+                receiverClass = autoclass(f"{get_package_name()}.{receiver_name}")
+                action_intent = Intent(context, receiverClass)
+                set_action(action_intent)
+                pending_action_intent = PendingIntent.getBroadcast(
+                    context, self.__no_of_buttons or 1, action_intent,
+                             PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_IMMUTABLE
+                )
+
+            except Exception as error_getting_broadcast_receiver:
+                print("android_notify- error_getting_broadcast_receiver:", error_getting_broadcast_receiver)
+                pending_action_intent = set_default_action_intent()
+
+        else:
+            pending_action_intent = set_default_action_intent()
+
+
+        self.__builder.addAction(int(context.getApplicationInfo().icon), action_text, pending_action_intent)
+        self.__builder.setContentIntent(pending_action_intent)  # Set content intent for notification tap
+
+        self.btns_box[action] = on_release
+        self.__no_of_buttons += 1
+        # action_intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+        if self.logs:
+            print('Added Button: ', text)
+            print('Button action: ', action)
+
+    def removeButtons(self):
+        """Removes all notification buttons
+        """
+        if ON_ANDROID:
+            self.__builder.mActions.clear()
+            self.refresh()
+        if self.logs:
+            print('Removed Notification Buttons')
+
+    @run_on_ui_thread
+    def addNotificationStyle(self, style: str, already_sent=False):
+        """Adds Style to Notification
+
+        Note: This method has Deprecated Use - (setLargeIcon, setBigPicture, setBigText and setLines) Instead
+
+        Args:
+            style (str): required style
+            already_sent (bool,False): If notification was already sent
+        """
+
+        if not ON_ANDROID:
+            # TODO for logs when not on android and style related to imgs extract app path from buildozer.spec and print
+            return False
+
+        if self.body:
+            self.setBigText(self.body)
+
+        elif self.lines_txt:
+            lines = self.lines_txt.split("\n")
+            self.setLines(lines)
+
+        elif self.big_picture_path or self.large_icon_path:
+            if self.big_picture_path:
+                self.setBigPicture(self.big_picture_path)
+            if self.large_icon_path:
+                self.setLargeIcon(self.large_icon_path)
+
+        elif self.progress_max_value or self.progress_current_value:
+            self.__builder.setProgress(self.progress_max_value, self.progress_current_value or 0.1, False)
+
+        if already_sent:
+            self.refresh()
+
+        return True
+
+    def setLines(self, lines: list):
+        """Pass in a list of strings to be used for lines"""
+        if not lines:
+            return
+        if ON_ANDROID:
+            inbox_style = NotificationCompatInboxStyle()
+            for line in lines:
+                inbox_style.addLine(str(line))
             self.__builder.setStyle(inbox_style)
-            
-        elif self.style == "big_picture" and big_pic_javapath:
-            big_pic_bitmap = self.__getBitmap(big_pic_javapath)
-            big_picture_style = NotificationCompatBigPictureStyle().bigPicture(big_pic_bitmap) # pylint: disable=E0606
-            self.__builder.setStyle(big_picture_style)
-        
-        elif self.style == "large_icon" and large_icon_javapath:
-            large_icon_bitmap = self.__getBitmap(large_icon_javapath)
-            self.__builder.setLargeIcon(large_icon_bitmap)
-        
-        elif self.style == 'both_imgs' and (large_icon_javapath or big_pic_javapath):
-            if big_pic_javapath:
-                big_pic_bitmap = self.__getBitmap(big_pic_javapath)
-                big_picture_style = NotificationCompatBigPictureStyle().bigPicture(big_pic_bitmap)
+            print('Set Lines: ', lines)
+
+        if self.logs:
+            print('Added Lines: ', lines)
+
+    def setSound(self, res_sound_name):
+        """
+        Sets sound for devices less than android 8 (For 8+ use createChannel)
+        :param res_sound_name: audio file file name (without .wav or .mp3) locate in res/raw/
+        """
+
+        if not ON_ANDROID:
+            return
+
+        if res_sound_name and BuildVersion.SDK_INT < 26:
+            try:
+                self.__builder.setSound(get_sound_uri(res_sound_name))
+            except Exception as failed_adding_sound_device_below_android8:
+                print("failed_adding_sound_device_below_android8:", failed_adding_sound_device_below_android8)
+                traceback.print_exc()
+
+    def __dispatch_notification(self):
+        # self.passed_check is for self.send_() some devices don't return true when checking for permission when it's actually True in settingsAdd commentMore actions
+        # And so users can do Notification.passed_check = True at top of their file and use regular .send()
+
+        if from_service_file():  # android has_permission has some internal error when checking from service
+            try:
+                self.notification_manager.notify(self.__id, self.__builder.build())
+            except Exception as sending_notification_from_service_error:
+                print('error sending notification from service:', sending_notification_from_service_error)
+        elif on_flet_app() or self.passed_check or NotificationHandler.has_permission():
+            try:
+                self.notification_manager.notify(self.__id, self.__builder.build())
+            except Exception as notify_error:
+                print('Exception:', notify_error)
+                print('Failed to send traceback:', traceback.format_exc())
+        else:
+            print('Permission not granted to send notifications')
+            # TODO find way to open app notification settings and not ask only through POP-UP
+            # Not asking for permission too frequently, This makes dialog popup to stop showing
+            # NotificationHandler.asks_permission()
+
+    def start_building(self, persistent=False, close_on_click=True, silent: bool = False):
+        # Main use is for foreground service, bypassing .notify in .send method to let service.startForeground(...) send it
+        self.silent = silent or self.silent
+        if not ON_ANDROID:
+            return NotificationCompatBuilder  # this is just a facade
+        self.__create_basic_notification(persistent, close_on_click)
+        if self.style not in ['simple', '']:
+            self.addNotificationStyle(self.style)
+        self.__applyNewLinesIfAny()
+
+        return self.__builder
+
+    def __applyNewLinesIfAny(self):
+        if self.__lines:
+            self.setLines(self.__lines)
+            self.__lines = []  # for refresh method to known when new lines added
+
+    def __create_basic_notification(self, persistent, close_on_click):
+        if not self.channelExists(self.channel_id):
+            self.createChannel(self.channel_id, self.channel_name)
+        elif not self.__using_set_priority_method:
+            self.setPriority('medium' if self.silent else 'urgent')
+
+        # Build the notification
+        if self.isUsingCustom():
+            self.__apply_basic_custom_style()
+        else:
+            self.__builder.setContentTitle(str(self.title))
+            self.__builder.setContentText(str(self.message))
+        self.__insert_app_icon()
+        self.__builder.setDefaults(AndroidNotification.DEFAULT_ALL)
+        self.__builder.setOnlyAlertOnce(True)
+        self.__builder.setOngoing(persistent)
+        self.__builder.setAutoCancel(close_on_click)
+
+        try:
+            self.__add_intent_to_open_app()
+        except Exception as failed_to_add_intent_to_open_app:
+            print('failed_to_add_intent_to_open_app Error: ', failed_to_add_intent_to_open_app)
+            traceback.print_exc()
+
+        self.__built_parameter_filled = True
+
+    def __insert_app_icon(self, path=''):
+        if BuildVersion.SDK_INT >= 23 and (path or self.app_icon not in ['', 'Defaults to package app icon']):
+            # Bitmap Insert as Icon Not available below Android 6
+            if self.logs:
+                print('getting custom icon...')
+            self.__set_icon_from_bitmap(path or self.app_icon)
+        else:
+            def set_default_icon():
+                if self.logs:
+                    print('using default icon...')
+                self.__builder.setSmallIcon(context.getApplicationInfo().icon)
+
+            fallback_icon_path = None
+            if on_flet_app():
+                fallback_icon_path = icon_finder("flet-appicon.png")
+            elif "ru.iiec.pydroid3" in os.path.dirname(os.path.abspath(__file__)):
+                fallback_icon_path = icon_finder("pydroid3-appicon.png")
+            else:
+                set_default_icon()
+
+            if fallback_icon_path:
+                success = self.__set_smallicon_with_bitmap_from_path(fallback_icon_path)
+                if not success:
+                    print("error_using_fallback_appicon")
+                    set_default_icon()
+
+            self.__has_small_icon = True
+
+    def __set_smallicon_with_bitmap_from_path(self, fullpath):
+        try:
+            bitmap = get_bitmap_from_path(fullpath)
+            if bitmap:
+                self.__set_builder_icon_with_bitmap(bitmap)
+                return True
+        except Exception as error_using_bitmap_for_appicon:
+            print("error_using_bitmap_for_appicon :", error_using_bitmap_for_appicon)
+            traceback.print_exc()
+        return False
+
+    def __build_img(self, user_img, img_style):
+        if user_img.startswith('http://') or user_img.startswith('https://'):
+            def callback(bitmap_):
+                self.__apply_notification_image(bitmap_, img_style)
+
+            thread = threading.Thread(
+                target=get_bitmap_from_url,
+                args=[user_img, callback, self.logs]
+            )
+            thread.start()
+        else:
+            bitmap = get_img_from_path(user_img)
+            if bitmap:
+                self.__apply_notification_image(bitmap, img_style)
+
+    def __set_icon_from_bitmap(self, img_path):
+        """Path can be a link or relative path"""
+
+        if img_path.startswith('http://') or img_path.startswith('https://'):
+            def callback(bitmap_):
+                if bitmap_:
+                    self.__set_builder_icon_with_bitmap(bitmap_)
+                else:
+                    if self.logs:
+                        print('Using Default Icon as fallback......')
+                    self.__builder.setSmallIcon(context.getApplicationInfo().icon)
+                self.__has_small_icon = True
+
+            threading.Thread(
+                target=get_bitmap_from_url,
+                args=[img_path, callback, self.logs]
+            ).start()
+        else:
+            bitmap = get_img_from_path(
+                img_path)  # get_img_from_path is different from get_bitmap_from_path because it those some logging for user
+            if bitmap:
+                self.__set_builder_icon_with_bitmap(bitmap)
+            else:
+                if self.logs:
+                    app_folder = os.path.join(app_storage_path(), 'app')
+                    img_absolute_path = os.path.join(app_folder, img_path)
+                    print(
+                        f'Failed getting bitmap for custom notification icon defaulting to app icon\n absolute path {img_absolute_path}')
+                self.__builder.setSmallIcon(context.getApplicationInfo().icon)
+            self.__has_small_icon = True
+
+    def __set_builder_icon_with_bitmap(self, bitmap):
+        try:
+            Icon = autoclass('android.graphics.drawable.Icon')
+        except Exception as autoclass_icon_error:
+            print("Couldn't find class to set custom icon:", autoclass_icon_error)
+            self.__builder.setSmallIcon(context.getApplicationInfo().icon)
+            self.__has_small_icon = True
+            return
+
+        Icon = autoclass('android.graphics.drawable.Icon')
+        icon = Icon.createWithBitmap(bitmap)
+        self.__builder.setSmallIcon(icon)
+
+    @run_on_ui_thread
+    def __apply_notification_image(self, bitmap, img_style):
+        try:
+            if img_style == NotificationStyles.BIG_PICTURE and bitmap:
+                big_picture_style = NotificationCompatBigPictureStyle().bigPicture(bitmap)
                 self.__builder.setStyle(big_picture_style)
-            elif large_icon_javapath:
-                large_icon_bitmap = self.__getBitmap(large_icon_javapath)
-                self.__builder.setLargeIcon(large_icon_bitmap)
-        elif self.style == 'progress':
-            self.__builder.setContentTitle(String(self.title))
-            self.__builder.setContentText(String(self.message))
-            self.__builder.setProgress(self.progress_max_value, self.progress_current_value, False)
-        # elif self.style == 'custom':
-        #     self.__builder = self.__doCustomStyle()
-
-    # def __doCustomStyle(self):
-    #     # TODO Will implement when needed
-    #     return self.__builder
-
-    def __getUniqueID(self):
-        reasonable_amount_of_notifications=101
-        notification_id = random.randint(1, reasonable_amount_of_notifications)
-        while notification_id in self.notification_ids:
-            notification_id = random.randint(1, 100)
+            elif img_style == NotificationStyles.LARGE_ICON and bitmap:
+                self.__builder.setLargeIcon(bitmap)
+            # LargeIcon requires smallIcon to be already set
+            # 'setLarge, setBigPic' tries to dispatch before filling required values `self.__create_basic_notification`
+            self.refresh()
+            if self.logs:
+                print('Done adding image to notification-------')
+        except Exception as notification_image_error:
+            img = self.large_icon_path if img_style == NotificationStyles.LARGE_ICON else self.big_picture_path
+            print(
+                f'Failed adding Image of style: {img_style} || From path: {img}, Exception {notification_image_error}')
+            print('could not get Img traceback: ', traceback.format_exc())
+
+    def __add_intent_to_open_app(self):
+        intent = Intent(context, PythonActivity)
+        intent.setFlags(
+            Intent.FLAG_ACTIVITY_CLEAR_TOP |  # Makes Sure tapping notification always brings the existing instance of app forward.
+            Intent.FLAG_ACTIVITY_SINGLE_TOP |  # If the activity is already at the top, reuse it instead of creating a new instance.
+            Intent.FLAG_ACTIVITY_NEW_TASK
+            # Required when starting an Activity from a Service; ignored when starting from another Activity.
+        )
+        action = str(self.name or self.__id)
+        intent.setAction(action)
+        add_data_to_intent(intent, self.title)
+        self.main_functions[action] = self.callback
+
+        #intent.setAction(Intent.ACTION_MAIN)      # Marks this intent as the main entry point of the app, like launching from the home screen.
+        #intent.addCategory(Intent.CATEGORY_LAUNCHER)  # Adds the launcher category so Android treats it as a launcher app intent and properly manages the task/back stack.
+
+        pending_intent = PendingIntent.getActivity(
+            context, 0,
+            intent, PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+        )
+        self.__builder.setContentIntent(pending_intent)
+
+    def __format_channel(self, channel_name: str = 'Default Channel', channel_id: str = 'default_channel'):
+        """
+        Formats and sets self.channel_name and self.channel_id to a formatted version
+        :param channel_name:
+        :param channel_id:
+        :return:
+        """
+        # Shorten channel name # android docs as at most 40 chars
+        if channel_name != 'Default Channel':
+            cleaned_name = channel_name.strip()
+            self.channel_name = cleaned_name[:40] if cleaned_name else 'Default Channel'
+
+            # If no channel_id then generating channel_id from passed in channel_name
+            if channel_id == 'default_channel':
+                generated_id = generate_channel_id(channel_name)
+                self.channel_id = generated_id
+
+    def __get_unique_id(self):
+        if from_service_file():
+            max_int = 2_147_483_647
+            return int(time.time() * 1000) % max_int
+
+        notification_id = self.notification_ids[-1] + 1
         self.notification_ids.append(notification_id)
         return notification_id
 
-    def __asks_permission_if_needed(self):
-        """
-        Ask for permission to send notifications if needed.
+    @classmethod
+    def getChannels(cls) -> list[Any] | Any:
+        """Return all existing channels"""
+        if not ON_ANDROID:
+            return []
+
+        return get_notification_manager().getNotificationChannels()
+
+    def __apply_basic_custom_style(self):
+        NotificationCompatDecoratedCustomViewStyle = autoclass(
+            'androidx.core.app.NotificationCompat$DecoratedCustomViewStyle')
+
+        # Load layout
+        resources = context.getResources()
+        package_name = context.getPackageName()
+
+        # ids
+        small_layout_id = resources.getIdentifier("an_colored_basic_small", "layout", package_name)
+        large_layout_id = resources.getIdentifier("an_colored_basic_large", "layout", package_name)
+        title_id = resources.getIdentifier("title", "id", package_name)
+        message_id = resources.getIdentifier("message", "id", package_name)
+
+        # Layout
+        notificationLayout = RemoteViews(package_name, small_layout_id)
+        notificationLayoutExpanded = RemoteViews(package_name, large_layout_id)
+
+        if DEV:
+            print('small: ', small_layout_id, 'notificationLayout: ', notificationLayout)
+
+        # Notification Content
+        setLayoutText(
+            layout=notificationLayout, id=title_id,
+            text=self.title, color=self.title_color
+        )
+        setLayoutText(
+            layout=notificationLayoutExpanded, id=title_id,
+            text=self.title, color=self.title_color
+        )
+        setLayoutText(
+            layout=notificationLayoutExpanded, id=message_id,
+            text=self.message, color=self.message_color
+        )
+        # self.__setLayoutText(
+        #     layout=notificationLayout, id=message_id,
+        #     text=self.message, color=self.message_color
+        # )
+        if not self.__built_parameter_filled:
+            current_time_mills = int(time.time() * 1000)
+            self.__builder.setWhen(current_time_mills)
+            self.__builder.setShowWhen(True)
+        self.__builder.setStyle(NotificationCompatDecoratedCustomViewStyle())
+        self.__builder.setCustomContentView(notificationLayout)
+        self.__builder.setCustomBigContentView(notificationLayoutExpanded)
+
+    def isUsingCustom(self):
+        self.__using_custom = self.title_color or self.message_color
+        return bool(self.__using_custom)
+    # TODO method to create channel groups
+
+
+class NotificationHandler:
+    """For Notification Operations """
+    __name = None
+    __bound = False
+    __requesting_permission = False
+    android_activity = None
+    if ON_ANDROID and not on_flet_app():
+        from android import activity
+        android_activity = activity
+
+    @classmethod
+    def get_name(cls):
+        """Returns name or id str for Clicked Notification."""
+        if not cls.is_on_android():
+            return "Not on Android"
+
+        saved_intent = cls.__name
+        cls.__name = None  # so value won't be set when opening app not from notification
+        # print('saved_intent ',saved_intent)
+        # if not saved_intent or (isinstance(saved_intent, str) and saved_intent.startswith("android.intent")):
+            # All other notifications are not None after First notification opens app
+            # NOTE these notifications are also from Last time app was opened and they Still Give Value after first one opens App
+            # TODO Find a way to get intent when App if Swiped From recents
+            # Below action is always None
+            # __PythonActivity = autoclass(ACTIVITY_CLASS_NAME)
+            # __mactivity = __PythonActivity.mActivity
+            # __context = cast('android.content.Context', __mactivity)
+            # __Intent = autoclass('android.content.Intent')
+            # __intent = __Intent(__context, __PythonActivity)
+            # action = __intent.getAction()
+            # print('Start up Intent ----', action)
+            # print('start Up Title --->',__intent.getStringExtra("title"))
+
+        return saved_intent
+
+    @classmethod
+    def __notification_handler(cls, intent):
+        """Calls Function Attached to notification on click.
+            Don't Call this function manual, it's Already Attach to Notification.
+
+        Sets self.__name #action of Notification that was clicked from Notification.name or Notification.id
         """
-        def on_permissions_result(permissions, grant): # pylint: disable=unused-argument
-            if self.logs:
-                print("Permission Grant State: ",grant)
+        if not cls.is_on_android():
+            return "Not on Android"
+        #print('intent.getStringExtra("title")',intent.getStringExtra("title"))
+        buttons_object = Notification.btns_box
+        notifty_functions = Notification.main_functions
+        if DEV:
+            print("notify_functions ", notifty_functions)
+            print("buttons_object", buttons_object)
+        try:
+            action = intent.getAction()
+            cls.__name = action
+
+            # print("The Action --> ",action)
+            if action == "android.intent.action.MAIN":  # Not Open From Notification
+                cls.__name = None
+                return 'Not notification'
 
-        permissions=[Permission.POST_NOTIFICATIONS] # pylint: disable=E0606
-        if not all(check_permission(p) for p in permissions):
-            request_permissions(permissions,on_permissions_result) # pylint: disable=E0606
+            # print(intent.getStringExtra("title"))
+            try:
+                if action in notifty_functions and notifty_functions[action]:
+                    notifty_functions[action]()
+                elif action in buttons_object:
+                    if buttons_object[action]:
+                        buttons_object[action]()
+                    else:
+                        print("android_notify- Notification button function not found got:", buttons_object[action])
+            except Exception as notification_handler_function_error:
+                print("Error Type ", notification_handler_function_error)
+                print('Failed to run function: ', traceback.format_exc())
+        except Exception as extracting_notification_props_error:
+            print('Notify Handler Failed ', extracting_notification_props_error)
 
-    def __get_image_uri(self,relative_path):
+    @classmethod
+    def bindNotifyListener(cls):
+        """This Creates a Listener for All Notification Clicks and Functions"""
+        if on_flet_app():
+            return False
+
+        if not cls.is_on_android():
+            return "Not on Android"
+        # TODO keep trying BroadcastReceiver
+        if cls.__bound:
+            print("binding done already ")
+            return True
+        try:
+            cls.android_activity.bind(on_new_intent=cls.__notification_handler)
+            cls.__bound = True
+            return True
+        except Exception as binding_listener_error:
+            print('Failed to bin notifications listener', binding_listener_error)
+            return False
+
+    @classmethod
+    def unbindNotifyListener(cls):
+        """Removes Listener for Notifications Click"""
+        if not cls.is_on_android():
+            return "Not on Android"
+
+        # Beta TODO use BroadcastReceiver
+        if on_flet_app() or from_service_file():
+            return False  # error 'NoneType' object has no attribute 'registerNewIntentListener'
+        try:
+            cls.android_activity.unbind(on_new_intent=cls.__notification_handler)
+            return True
+        except Exception as unbinding_listener_error:
+            print("Failed to unbind notifications listener: ", unbinding_listener_error)
+            return False
+
+    @staticmethod
+    def is_on_android():
+        """Utility to check if the app is running on Android."""
+        return ON_ANDROID
+
+    @staticmethod
+    def has_permission():
         """
-        Get the absolute URI for an image in the assets folder.
-        :param relative_path: The relative path to the image (e.g., 'assets/imgs/icon.png').
-        :return: Absolute URI java Object (e.g., 'file:///path/to/file.png').
+        Checks if device has permission to send notifications
+        returns True if device has permission
         """
+        if not ON_ANDROID:
+            return True
 
-        output_path = os.path.join(app_storage_path(),'app', relative_path) # pylint: disable=possibly-used-before-assignment
-        # print(output_path)  # /data/user/0/(package.domain+package.name)/files/app/assets/imgs/icon.png | pylint: disable=:line-too-long
+        if BuildVersion.SDK_INT < 33:  # Android 12 below
+            print("android_notify- On android 12 or less don't need permission")
+            return True
 
-        if not os.path.exists(output_path):
-            # TODO Use images From Any where even Web
-            raise FileNotFoundError(f"Image not found at path: {output_path}, (Can Only Use Images in App Path)")
-        Uri = autoclass('android.net.Uri')
-        return Uri.parse(f"file://{output_path}")
-    def __getBitmap(self,img_path):
-        return BitmapFactory.decodeStream(context.getContentResolver().openInputStream(img_path))
+        if on_flet_app():
+            Manifest = autoclass('android.Manifest$permission')
+            VERSION_CODES = autoclass('android.os.Build$VERSION_CODES')
+            PackageManager = autoclass("android.content.pm.PackageManager")
+            permission = Manifest.POST_NOTIFICATIONS
+            return PackageManager.PERMISSION_GRANTED == context.checkSelfPermission(permission)
+        else:
+            from android.permissions import Permission, check_permission    # type: ignore
+            return check_permission(Permission.POST_NOTIFICATIONS)
 
-    def __generate_channel_id(self,channel_name: str) -> str:
+    @classmethod
+    @run_on_ui_thread
+    def asks_permission(cls, callback=None):
         """
-        Generate a readable and consistent channel ID from a channel name.
-        
-        Args:
-            channel_name (str): The name of the notification channel.
-        
-        Returns:
-            str: A sanitized channel ID.
-        """
-        # Normalize the channel name
-        channel_id = channel_name.strip().lower()
-        # Replace spaces and special characters with underscores
-        channel_id = re.sub(r'[^a-z0-9]+', '_', channel_id)
-        # Remove leading/trailing underscores
-        channel_id = channel_id.strip('_')
-        return channel_id[:50]
-
-# try:
-#     notify=Notification(titl='My Title',channel_name='Go')#,logs=False)
-#     # notify.channel_name='Downloads'
-#     notify.message="Blah"
-#     notify.send()
-#     notify.updateTitle('New Title')
-#     notify.updateMessage('New Message')
-#     notify.send(True)
-# except Exception as e:
-#     print(e)
-
-# notify=Notification(title='My Title1')
-# # notify.updateTitle('New Title1')
-# notify.send()
-
-
-# Notification.logs=False # Add in Readme
-# notify=Notification(style='large_icon',title='My Title',channel_name='Some thing about a thing ')#,logs=False)
-# # notify.channel_name='Downloads'
-# notify.message="Blah"
-# notify.send()
-# notify.updateTitle('New Title')
-# notify.updateMessage('New Message')
+        Ask for permission to send notifications if needed.
+        Passes True to callback if access granted
+        """
+        if not ON_ANDROID:
+            print("android_notify- Can't ask permission when not on android")
+            return None
+
+        if cls.__requesting_permission:
+            print("android_notify- still requesting permission ")
+            return True
+
+        if BuildVersion.SDK_INT < 33:  # Android 12 below
+            print("android_notify- On android 12 or less don't need permission")
+
+        if not ON_ANDROID or BuildVersion.SDK_INT < 33:  # Android 12 below:
+            try:
+                if callback:
+                    if can_accept_arguments(callback, True):
+                        callback(True)
+                    else:
+                        callback()
+            except Exception as request_permission_error:
+                print('Exception: ', request_permission_error)
+                print('Permission response callback error: ', traceback.format_exc())
+
+            return
+
+        if not can_show_permission_request_popup():
+            print("""android_notify- Permission to send notifications has been denied permanently.
+This happens when the user denies permission twice from the popup.
+Opening notification settings...""")
+            open_settings_screen()
+            return None
+
+        def on_permissions_result(permissions, grants):
+            try:
+                if callback:
+                    if can_accept_arguments(callback, True):
+                        callback(grants[0])
+                    else:
+                        callback()
+            except Exception as request_permission_error:
+                print('Exception: ', request_permission_error)
+                print('Permission response callback error: ', traceback.format_exc())
+            finally:
+                cls.__requesting_permission = False
+
+        if not cls.has_permission():
+            if on_flet_app():
+                Manifest = autoclass('android.Manifest$permission')
+                permission = Manifest.POST_NOTIFICATIONS
+                context.requestPermissions([permission], 101)
+                # TODO Callback when user answers request question
+            else:
+                from android.permissions import request_permissions, Permission # type: ignore
+                cls.__requesting_permission = True
+                request_permissions([Permission.POST_NOTIFICATIONS], on_permissions_result)
+                return None
+        else:
+            cls.__requesting_permission = False
+            if callback:
+                if can_accept_arguments(callback, True):
+                    callback(True)
+                else:
+                    callback()
+            return None
+
+
+if not on_flet_app() and from_service_file():
+    print("didn't bind listener, In service file")
+elif ON_ANDROID:
+    try:
+        NotificationHandler.bindNotifyListener()
+    except Exception as bind_error:
+        # error 'NoneType' object has no attribute 'registerNewIntentListener'
+        print("notification listener bind error:", bind_error)
+        traceback.print_exc()