android-notify 1.2__py3-none-any.whl → 1.5__py3-none-any.whl

android_notify/__init__.py

@@ -0,0 +1,4 @@
+""""For Easier Imports For Public Classes"""
+from .core import send_notification
+from .styles import NotificationStyles
+from .sword import Notification,NotificationHandler

android_notify/core.py

@@ -1,10 +1,10 @@
-
-from jnius import autoclass,cast
+""" Non-Advanced Stuff """
 import random
 import os
 
 ON_ANDROID = False
 try:
+    from jnius import autoclass,cast # Needs Java to be installed
     # Get the required Java classes
     PythonActivity = autoclass('org.kivy.android.PythonActivity')
     NotificationChannel = autoclass('android.app.NotificationChannel')
@@ -20,13 +20,12 @@ except Exception as e:
 
 if ON_ANDROID:
     try:
-        # NotificationManagerCompat = autoclass('androidx.core.app.NotificationManagerCompat')                                       
+        NotificationManagerCompat = autoclass('androidx.core.app.NotificationManagerCompat')                                       
         NotificationCompat = autoclass('androidx.core.app.NotificationCompat')
 
         # Notification Design
         NotificationCompatBuilder = autoclass('androidx.core.app.NotificationCompat$Builder')
         NotificationCompatBigTextStyle = autoclass('androidx.core.app.NotificationCompat$BigTextStyle')
-        # NotificationCompatBigTextStyle = autoclass('android.app.Notification$BigTextStyle')
         NotificationCompatBigPictureStyle = autoclass('androidx.core.app.NotificationCompat$BigPictureStyle')
         NotificationCompatInboxStyle = autoclass('androidx.core.app.NotificationCompat$InboxStyle')
     except Exception as e:
@@ -65,7 +64,14 @@ def get_image_uri(relative_path):
     return Uri.parse(f"file://{output_path}")
 
 
-def send_notification(title:str, message:str, style=None, img_path=None, channel_id:str="default_channel"):
+def send_notification(
+    title:str,
+    message:str,
+    style=None,
+    img_path=None,
+    channel_name="Default Channel",
+    channel_id:str="default_channel"
+    ):
     """
     Send a notification on Android.
 
@@ -73,21 +79,22 @@ def send_notification(title:str, message:str, style=None, img_path=None, channel
     :param message: Message body.
     :param style: Style of the notification ('big_text', 'big_picture', 'inbox', 'large_icon').
     :param img_path: Path to the image resource.
-    :param channel_id: Notification channel ID.
+    :param channel_id: Notification channel ID.(Default is lowercase channel name arg in lowercase)
     """
     if not ON_ANDROID:
         print('This Package Only Runs on Android !!! ---> Check "https://github.com/Fector101/android_notify/" for Documentation.')
         return
-    
+    asks_permission_if_needed()
+    channel_id=channel_name.replace(' ','_').lower().lower() if not channel_id else channel_id
     # Get notification manager
     notification_manager = context.getSystemService(context.NOTIFICATION_SERVICE)
 
-    importance= autoclass('android.app.NotificationManager').IMPORTANCE_HIGH # also works #NotificationManager.IMPORTANCE_DEFAULT
-    # importance= NotificationManagerCompat.IMPORTANCE_HIGH #autoclass('android.app.NotificationManager').IMPORTANCE_HIGH also works #NotificationManager.IMPORTANCE_DEFAULT
+    # importance= autoclass('android.app.NotificationManager').IMPORTANCE_HIGH # also works #NotificationManager.IMPORTANCE_DEFAULT
+    importance= NotificationManagerCompat.IMPORTANCE_HIGH #autoclass('android.app.NotificationManager').IMPORTANCE_HIGH also works #NotificationManager.IMPORTANCE_DEFAULT
     
     # Notification Channel (Required for Android 8.0+)
     if BuildVersion.SDK_INT >= 26:
-        channel = NotificationChannel(channel_id, "Default Channel",importance)
+        channel = NotificationChannel(channel_id, channel_name,importance)
         notification_manager.createNotificationChannel(channel)
 
     # Build the notification
@@ -98,7 +105,6 @@ def send_notification(title:str, message:str, style=None, img_path=None, channel
     builder.setDefaults(NotificationCompat.DEFAULT_ALL) 
     builder.setPriority(NotificationCompat.PRIORITY_HIGH)
     
-    # Get Image
     img=None
     if img_path:
         try:
@@ -112,8 +118,6 @@ def send_notification(title:str, message:str, style=None, img_path=None, channel
             big_text_style = NotificationCompatBigTextStyle()
             big_text_style.bigText(message)
             builder.setStyle(big_text_style)
-            
-            
         elif style == "big_picture" and img_path:
             bitmap = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(img))
             builder.setLargeIcon(bitmap)
@@ -132,4 +136,5 @@ def send_notification(title:str, message:str, style=None, img_path=None, channel
     # Display the notification
     notification_id = random.randint(0, 100)
     notification_manager.notify(notification_id, builder.build())
-    return notification_id
+    return notification_id
+

android_notify/styles.py

@@ -1,5 +1,15 @@
-class NotificationStyles:
-    BIG_TEXT = "big_text"
-    BIG_PICTURE = "big_picture"
+class NotificationStyles():
+    """ Safely Adding Styles"""
+    DEFAULT = "simple"
+    
+    PROGRESS = "progress"
     INBOX = "inbox"
+    BIG_TEXT = "big_text"
+    
     LARGE_ICON = "large_icon"
+    BIG_PICTURE = "big_picture"
+    BOTH_IMGS = "both_imgs"
+    
+    MESSAGING = "messaging" # TODO
+    CUSTOM = "custom" # TODO
+    

android_notify/sword.py

@@ -0,0 +1,547 @@
+"""This Module Contain Class for creating Notification With Java"""
+import difflib
+import traceback
+import os
+import re
+
+DEV=0
+ON_ANDROID = False
+
+try:
+    from jnius import autoclass,cast  # Needs Java to be installed pylint: disable=W0611, C0114
+    from android import activity # pylint: disable=import-error
+    from android.config import ACTIVITY_CLASS_NAME # pylint: disable=import-error
+
+    # Get the required Java classes
+    Bundle = autoclass('android.os.Bundle')
+    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:
+    """
+    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: Relative Path to the image resource.
+    :param large_icon_path: Relative Path to the image resource.
+    :param callback: Function for notification Click.
+    ---
+    (Advance Options)
+    :param channel_name: - str Defaults to "Default Channel"
+    :param channel_id: - str Defaults to "default_channel"
+    ---
+    (Options during Dev On PC)
+    :param logs: - Bool Defaults to True
+    """
+    notification_ids=[0]
+    button_ids=[0]
+    btns_box={}
+    main_functions={}
+    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': 0,
+        'progress_current_value': 0,
+        'channel_name':'Default Channel',
+        'channel_id':'default_channel',
+        'logs':True,
+        "identifer": '',
+        'callback': None
+    }
+    # 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=0
+
+        # For Nofitication Functions
+        self.identifer=''
+        self.callback = None
+
+        # Advance Options
+        self.channel_name='Default Channel'
+        self.channel_id='default_channel'
+        self.silent=False
+
+        # During Dev on PC
+        self.logs=self.logs
+
+        # Private (Don't Touch)
+        self.__id = self.__getUniqueID()
+        self.__setArgs(kwargs)
+
+        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)
+        self.__builder=NotificationCompatBuilder(context, self.channel_id)# pylint: disable=E0606
+
+    def updateTitle(self,new_title):
+        """Changes Old Title
+
+        Args:
+            new_title (str): New Notification Title
+        """
+        self.title=new_title
+        if ON_ANDROID:
+            self.__builder.setContentTitle(new_title)
+
+    def updateMessage(self,new_message):
+        """Changes Old Message
+
+        Args:
+            new_message (str): New Notification Message
+        """
+        self.message=new_message
+        if ON_ANDROID:
+            self.__builder.setContentText(new_message)
+
+    def updateProgressBar(self,current_value,message:str=''):
+        """message defaults to last message"""
+        if not ON_ANDROID:
+            return
+
+        if self.logs:
+            print(f'Progress Bar Update value: {current_value}')
+        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):
+        """Sends notification
+        
+        Args:
+            silent (bool): True if you don't want to show briefly on screen
+        """
+        self.silent=self.silent or silent
+        if ON_ANDROID:
+            self.__startNotificationBuild()
+            self.notification_manager.notify(self.__id, self.__builder.build())
+        elif self.logs:
+            string_to_display=''
+            for name,value in vars(self).items():
+                if value and name not in ['logs','_Notification__id']:
+                    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)
+            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' and value.strip():
+                setattr(self,key, value[:40])
+            elif key == 'channel_id' and value.strip(): # If user input's a channel id (i format properly)
+                setattr(self,key, self.__generate_channel_id(value))
+            else:
+                setattr(self,key, value if value else self.defaults[key])
+
+        if "channel_id" not in options_dict and 'channel_name' in options_dict: # if User doesn't input channel id but inputs channel_name
+            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+)
+        # print("THis is cchannel is ",self.channel_id) #"BLAH"
+        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
+            # importance = 3 or 4
+            channel = NotificationChannel(
+                self.channel_id,
+                self.channel_name,
+                importance
+            )
+            self.notification_manager.createNotificationChannel(channel)
+
+        # Build the notification
+        # self.__builder = NotificationCompatBuilder(context, self.channel_id)# pylint: disable=E0606
+        self.__builder.setContentTitle(str(self.title))
+        self.__builder.setContentText(str(self.message))
+        self.__builder.setSmallIcon(context.getApplicationInfo().icon)
+        self.__builder.setDefaults(NotificationCompat.DEFAULT_ALL) # pylint: disable=E0606
+        self.__builder.setPriority(NotificationCompat.PRIORITY_DEFAULT if self.silent else NotificationCompat.PRIORITY_HIGH)
+        self.__addIntentToOpenApp()
+    def __addNotificationStyle(self):
+        # pylint: disable=trailing-whitespace
+        
+        large_icon_javapath=None
+        if self.large_icon_path:
+            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)
+            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)
+                self.__builder.setStyle(big_picture_style)
+            if 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):
+        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.
+        """
+        def on_permissions_result(permissions, grant): # pylint: disable=unused-argument
+            if self.logs:
+                print("Permission Grant State: ",grant)
+
+        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
+
+    def __get_image_uri(self,relative_path):
+        """
+        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').
+        """
+
+        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 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))
+
+    def __generate_channel_id(self,channel_name: str) -> str:
+        """
+        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]
+
+    def __addIntentToOpenApp(self):
+        intent = Intent(context, PythonActivity)
+        action = str(self.identifer) or f"ACTION_{self.__id}"
+        intent.setAction(action)
+        self.__addDataToIntent(intent)
+        self.main_functions[action]=self.callback
+        intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+
+        pending_intent = PendingIntent.getActivity(
+                            context, 0,
+                            intent, PendingIntent.FLAG_IMMUTABLE if BuildVersion.SDK_INT >= 31 else PendingIntent.FLAG_UPDATE_CURRENT
+                        )
+        self.__builder.setContentIntent(pending_intent)
+        self.__builder.setAutoCancel(True)
+
+    def __addDataToIntent(self,intent):
+        """Persit Some data to notification object for later use"""
+        bundle = Bundle()
+        bundle.putString("title",  self.title or 'Title Placeholder')
+        bundle.putInt("notify_id", self.__id)
+        intent.putExtras(bundle)
+
+    def __getIDForButton(self):
+        btn_id = self.button_ids[-1] + 1
+        self.button_ids.append(btn_id)
+        return btn_id
+
+    def addButton(self, text:str,on_release):
+        """For adding action buttons
+
+        Args:
+            text (str): Text For Button
+        """
+        if self.logs:
+            print('Added Button: ', text)
+
+        if not ON_ANDROID:
+            return
+
+        btn_id= self.__getIDForButton()
+        action = f"BTN_ACTION_{btn_id}"
+
+        action_intent = Intent(context, PythonActivity)
+        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", 123)
+        action_intent.putExtras(bundle)
+        action_intent.putExtra("button_id", btn_id)
+
+        self.btns_box[action] = on_release
+        # action_intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+        if self.logs:
+            print('Button id: ',btn_id)
+        pending_action_intent = PendingIntent.getActivity(
+            context,
+            0,
+            action_intent,
+            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        )
+        # Convert text to CharSequence
+        action_text = cast('java.lang.CharSequence', String(text))
+
+
+
+        # Add action with proper types
+        self.__builder.addAction(
+            int(context.getApplicationInfo().icon),  # Cast icon to int
+            action_text,                             # CharSequence text
+            pending_action_intent                    # PendingIntent
+        )
+        # Set content intent for notification tap
+        self.__builder.setContentIntent(pending_action_intent)
+
+
+class NotificationHandler:
+    """For Notification Operations """
+    __identifer = None
+
+    @classmethod
+    def getIdentifer(cls):
+        """Returns identifer for Clicked Notification."""
+        if not cls.is_on_android():
+            return "Not on Android"
+
+        saved_intent = cls.__identifer
+        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
+            __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 __notificationHandler(cls,intent):
+        """Calls Function Attached to notification on click.
+            Don't Call this function manual, it's Already Attach to Notification.
+        
+        Returns:
+            str: The Identiter of Nofication that was clicked.
+        """
+        if not cls.is_on_android():
+            return "Not on Android"
+        buttons_object=Notification.btns_box
+        notifty_functions=Notification.main_functions
+        if DEV:
+            print("notifty_functions ",notifty_functions)
+            print("buttons_object", buttons_object)
+        action = None
+        try:
+            action = intent.getAction()
+            cls.__identifer = action
+
+            print("The Action --> ",action)
+            if action == "android.intent.action.MAIN": # Not Open From Notification
+                return 'Not notification'
+
+            print(intent.getStringExtra("title"))
+            try:
+                if action in notifty_functions and notifty_functions[action]:
+                    notifty_functions[action]()
+                elif action in buttons_object:
+                    buttons_object[action]()
+            except Exception as e: # pylint: disable=broad-exception-caught
+                print('Failed to run function: ', traceback.format_exc())
+                print("Error Type ",e)
+        except Exception as e: # pylint: disable=broad-exception-caught
+            print('Notify Hanlder Failed ',e)
+        return action
+
+    @classmethod
+    def bindNotifyListener(cls):
+        """Binds the notification listener.\n\n
+            ```
+                from kivy.app import App
+                from android_notify import bindNotifyListener
+                class Myapp(App):
+                    def on_start(self):
+                        bindNotifyListener() # if successfull returns True
+            ```
+        """
+        if not cls.is_on_android():
+            return "Not on Android"
+        #Beta TODO Automatic bind when Notification object is called the first time use keep trying BroadcastReceiver
+        try:
+            activity.bind(on_new_intent=cls.__notificationHandler)
+            return True
+        except Exception as e: # pylint: disable=broad-exception-caught
+            print('Failed to bin notitfications listener',e)
+            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
+        try:
+            activity.unbind(on_new_intent=cls.__notificationHandler)
+            return True
+        except Exception as e: # pylint: disable=broad-exception-caught
+            print("Failed to unbind notifications listener: ",e)
+            return False
+
+    @staticmethod
+    def is_on_android():
+        """Utility to check if the app is running on Android."""
+        return ON_ANDROID

android_notify-1.5.dist-info/METADATA

@@ -0,0 +1,452 @@
+Metadata-Version: 2.2
+Name: android-notify
+Version: 1.5
+Summary: A Python package that simpilfies creating Android notifications in Kivy apps.
+Home-page: https://github.com/fector101/android-notify
+Author: Fabian
+Author-email: fector101@yahoo.com
+License: MIT
+Project-URL: Documentation, https://github.com/fector101/android-notify/
+Project-URL: Source, https://github.com/fector101/android-notify
+Project-URL: Tracker, https://github.com/fector101/android-notify/issues
+Project-URL: Funding, https://www.buymeacoffee.com/fector101
+Keywords: android,notifications,kivy,mobile,post-notifications,pyjnius,android-notifications,kivy-notifications,python-android,mobile-development,push-notifications,mobile-app,kivy-application
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Android
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: kivy>=2.0.0
+Requires-Dist: pyjnius>=1.4.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<div align="center">
+    <br>
+    <h1> Android-Notifiy </h1>
+    <p> A Python library for effortlessly creating and managing Android notifications in Kivy android apps.</p>
+    <p>Supports various styles and ensures seamless integration and customization.</p>
+    <!-- <br> -->
+    <!-- <img src="https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/democollage.jpg"> -->
+</div>
+
+## Features
+
+- Also Compatible with Android 8.0+.
+- Supports including images in notifications.
+- All Notifications can take Functions (version 1.5+) [functions docs](#functions).
+- Support for multiple notification styles:
+  - [Simple](#basic-usage)
+  - [Progress](#progress-bar-notification)
+  - [Big Picture](#notification-with-an-image-big-picture-style)
+  - [Inbox](#inbox-notification-style)
+  - [Large Icon](#notification-with-an-image-large-icon-style)
+  - [Buttons](#notification-with-buttons)
+  - [Big Text](#big-text-notification-will-display-as-simple-text-if-device-dosent-support)
+
+This module automatically handles:
+
+- Permission requests for notifications
+- Customizable notification channels.
+
+## Installation
+
+This package is available on PyPI and can be installed via pip:
+
+```bash
+pip install android-notify
+```
+
+## **Dependencies**
+
+**Prerequisites:**  
+
+- Kivy
+
+In your **`buildozer.spec`** file, ensure you include the following:
+
+```ini
+# Add pyjnius so ensure it's packaged with the build
+requirements = python3, kivy, pyjnius, android-notify
+
+# Add permission for notifications
+android.permissions = POST_NOTIFICATIONS
+
+# Required dependencies (write exactly as shown, no quotation marks)
+android.gradle_dependencies = androidx.core:core:1.6.0, androidx.core:core-ktx:1.15.0
+android.enable_androidx = True
+```
+
+---
+
+## Basic Usage
+
+```python
+from android_notify import Notification
+
+# Create a simple notification
+notification = Notification(
+    title="Hello",
+    message="This is a basic notification."
+)
+notification.send()
+```
+
+**Sample Image:**  
+![basic notification img sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/basicnoti.jpg)
+
+## Notification Styles
+
+The library supports multiple notification styles:
+
+1. `simple` - Basic notification with title and message
+2. `progress` - Shows a progress bar
+3. `big_text` - Expandable notification with long text
+4. `inbox` - List-style notification
+5. `big_picture` - Notification with a large image
+6. `large_icon` - Notification with a custom icon
+7. `both_imgs` - Combines big picture and large icon
+8. `custom` - For custom notification styles
+
+### Style Examples
+
+#### Progress Bar notification
+
+```python
+from kivy.clock import Clock
+
+notification = Notification(
+    title="Downloading...",
+    message="0% downloaded",
+    style="progress",
+    progress_max_value=100,
+    progress_current_value=0
+)
+notification.send()
+Clock.schedule_once(lambda dt: notification.updateProgressBar(30, "30% downloaded"), 350)
+```
+
+**Sample Image:**
+![progress img sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/progress.jpg)
+
+#### Notification with an Image (Big Picture Style)
+
+```python
+# Image notification
+notification = Notification(
+    title='Picture Alert!',
+    message='This notification includes an image.',
+    style="big_picture",
+    big_picture_path="assets/imgs/photo.png"
+)
+notification.send()
+
+```
+
+**Sample Image:**
+![big_picture img sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/bigpicturenoti.jpg)
+
+#### Inbox Notification Style
+
+```python
+# Send a notification with inbox style
+notification = Notification(
+    title='Inbox Notification',
+    message='Line 1\nLine 2\nLine 3',
+    style='inbox'
+)
+notification.send()
+
+```
+
+**Sample Image:**
+![Inbox Notification sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/inboxnoti.jpg)
+
+#### Notification with an Image (Large Icon Style)
+
+```python
+notification = Notification(
+    title="FabianDev_",
+    message="A twitter about some programming stuff",
+    style="large_icon",
+    large_icon_path="assets/imgs/profile.png"
+)
+
+```
+
+**Sample Image:**  
+![large_icon img sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/large_icon.jpg)
+
+#### Notification with Buttons
+
+```python
+notification = Notification(title="Jane Dough", message="How to use android-notify #coding #purepython")
+def playVideo():
+    print('Playing Video')
+
+def turnOffNoti():
+    print('Please Turn OFf Noti')
+
+def watchLater():
+    print('Add to Watch Later')
+
+notification.addButton(text="Play",on_release=playVideo)
+notification.addButton(text="Turn Off",on_release=turnOffNoti)
+notification.addButton(text="Watch Later",on_release=watchLater)
+notification.send()
+```
+
+**Sample Image:**  
+![btns img sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/btns.jpg)
+
+#### Big text notification (Will Display as normal text if Device dosen't support)
+
+```python
+notification = Notification(
+    title="Article",
+    message="Long article content...",
+    style="big_text"
+)
+```
+
+## Advanced Features
+
+### Updating Notifications
+
+```python
+notification = Notification(title="Initial Title")
+notification.send()
+
+# Update title
+notification.updateTitle("New Title")
+
+# Update message
+notification.updateMessage("New Message")
+```
+
+### Progress Bar Management
+
+```python
+notification = Notification(
+    title="Download..",
+    style="progress"
+)
+
+# Update progress
+notification.updateProgressBar(30, "30% downloaded")
+
+# Remove progress bar
+notification.removeProgressBar("Download Complete")
+```
+
+### Channel Management
+
+Notifications are organized into channels. You can customize the channel name and ID:
+
+- Custom Channel Name's Gives User ability to turn on/off specific
+
+```python
+notification = Notification(
+    title="Download finished",
+    message="How to Catch a Fish.mp4",
+    channel_name="Download Notifications",  # Will create User-visible name "Download Notifications"
+    channel_id="downloads_notifications"  # Optional: specify custom channel ID
+)
+```
+
+**Sample Image:**  
+![channels img sample](https://raw.githubusercontent.com/Fector101/android_notify/main/docs/imgs/channel_name.jpg)
+
+### Silent Notifications
+
+To send a notification without sound or heads-up display:
+
+```python
+notification = Notification(title="Silent Update")
+notification.send(silent=True)
+```
+
+## Functions
+
+### NotificationHandler - To Attach Listener
+
+Add this to your main.py App Class so it runs Once, In later Versions It'll be Attached Automatical
+
+```python
+from kivymd.app import MDApp
+from android_notify import Notification, NotificationHandler
+
+class Myapp(MDApp):
+
+    def on_start(self):
+        # Is called Once when app is Starts up
+        NotificationHandler.bindNotifyListener() # if successfull returns True
+        Notification(title="Hello", message="This is a basic notification.",callback=self.doSomething).send()
+
+    def doSomething(self):
+        print("print in Debug Console")
+```
+
+### Get Which Notification was used to Open App - identifer (str)
+
+If you just want to get the Exact Notification Clicked to Open App, you can use NotificationHandler to get unique identifer
+
+```python
+from kivymd.app import MDApp
+from android_notify import Notification, NotificationHandler
+
+class Myapp(MDApp):
+    
+    def on_start(self):
+        
+        notify = Notification(title="Change Page", message="Click to change App page.", identifer='change_app_page')
+        notify.send()
+
+        notify1 = Notification(title="Change Colour", message="Click to change App Colour", identifer='change_app_color')
+        notify1.send()
+
+        NotificationHandler.bindNotifyListener()
+        
+    def on_resume(self):
+        # Is called everytime app is reopened
+        notify_identifer = NotificationHandler.getIdentifer()
+        if notify_identifer == 'change_app_page':
+            # Code to change Screen
+            pass
+        elif notify_identifer == 'change_app_color':
+            # Code to change Screen Color
+            pass
+```
+
+
+
+### Assist
+
+- How to Copy image to app folder
+
+```python
+import shutil,os # These modules come packaged with python
+from android.storage import app_storage_path # type: ignore -- This works only on android 
+
+app_path = os.path.join(app_storage_path(),'app')
+image_path= "/storage/emulated/0/Download/profile.png"
+
+shutil.copy(image_path, os.path.join(app_path, "profile.png"))
+```
+
+- Avoiding Human Error when using different notification styles
+
+```python
+from android_notify import Notification, NotificationStyles
+Notification(
+    title="New Photo",
+    message="Check out this image",
+    style=NotificationStyles.BIG_PICTURE,
+    big_picture_path="assets/imgs/photo.png"
+).send()
+```
+
+## Development Mode
+
+When developing on non-Android platforms, the library provides debugging output:
+
+```python
+# Enable logs (default is True when not on Android)
+Notification.logs = True
+
+# Create notification for testing
+notification = Notification(title="Test")
+notification.send()
+# Will print notification properties instead of sending
+```
+
+## Image Requirements
+
+- Images must be located within your app's folder
+- Supported paths are relative to your app's storage path
+- Example: `assets/imgs/icon.png`
+
+## Error Handling
+
+The library validates arguments and provides helpful error messages:
+
+- Invalid style names will suggest the closest matching style
+- Invalid arguments will list all valid options
+- Missing image files will raise FileNotFoundError with the attempted path
+
+## Limitations
+
+1. Only works on Android devices
+2. Images must be within the app's storage path
+3. Channel names are limited to 40 characters
+4. Channel IDs are limited to 50 characters
+
+## Best Practices
+
+1. Always handle permissions appropriately
+2. Use meaningful channel names for organization
+3. Keep progress bar updates reasonable (don't update too frequently)
+4. Test notifications on different Android versions
+5. Consider using silent notifications for frequent updates
+
+## Debugging Tips
+
+1. Enable logs during development: `Notification.logs = True`
+2. Check channel creation with Android's notification settings
+3. Verify image paths before sending notifications
+4. Test different styles to ensure proper display
+
+Remember to check Android's notification documentation for best practices and guidelines regarding notification frequency and content.
+
+## Contribution
+
+Feel free to open issues or submit pull requests for improvements!
+
+## Reporting Issues
+
+Found a bug? Please open an issue on our [GitHub Issues](https://github.com/Fector101/android_notify/issues) page.
+
+## Author
+
+- Fabian - <fector101@yahoo.com>
+- GitHub: [Android Notify Repo](https://github.com/Fector101/android_notify)
+- Twitter: [FabianDev_](https://twitter.com/intent/user?user_id=1246911115319263233)
+
+For feedback or contributions, feel free to reach out!
+
+---
+
+## ☕ Support the Project
+
+If you find this project helpful, consider buying me a coffee! 😊 Or Giving it a star on 🌟 [GitHub](https://github.com/Fector101/android_notify/) Your support helps maintain and improve the project.
+
+<a href="https://www.buymeacoffee.com/fector101" target="_blank">
+  <img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="60">
+</a>
+
+---
+
+## Acknowledgments
+
+- This Project was thoroughly Tested by the [Laner Project](https://github.com/Fector101/Laner/) - A application for Securely Transfering Files Wirelessly between your PC and Phone.
+- Thanks to the Kivy and Pyjnius communities.
+
+---
+
+## 🌐 **Links**
+
+- **PyPI:** [android-notify on PyPI](https://pypi.org/project/android-notify/)
+- **GitHub:** [Source Code Repository](https://github.com/Fector101/android_notify/)

android_notify-1.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+android_notify/__init__.py,sha256=lcLjyfegXgU7cyGhfSphAOBipXwemrVkdYy3mcF6X5Y,172
+android_notify/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+android_notify/core.py,sha256=B3gOgbLGGI6tz-Q_T2wmk74oggOSDX0Qz4lqj00vaFo,6114
+android_notify/styles.py,sha256=I2p31qStg9DaML9U4nXRvdpGzpppK6RS-qlDKuOv_Tk,328
+android_notify/sword.py,sha256=6dmlTQRYtuhHUyO8E4fh3YlnLJC1FCvkLtgBKGvJnmI,23252
+android_notify-1.5.dist-info/METADATA,sha256=D-xTAAdOyVgeK_kqcZL1cU_HAbwcFvJkwi6smOIE41Y,13161
+android_notify-1.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+android_notify-1.5.dist-info/top_level.txt,sha256=IR1ONMrRSRINZpWn2X0dL5gbWwWINsK7PW8Jy2p4fU8,15
+android_notify-1.5.dist-info/RECORD,,

{android_notify-1.2.dist-info → android_notify-1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

android_notify-1.2.dist-info/METADATA

@@ -1,210 +0,0 @@
-Metadata-Version: 2.1
-Name: android_notify
-Version: 1.2
-Summary: A Python package for sending Android notifications.
-Home-page: https://github.com/Fector101/android_notify/
-Author: Fabian
-Author-email: fabianjoseph063@gmail.com
-Project-URL: Funding, https://buymeacoffee.com/fector101
-Project-URL: Source, https://github.com/Fector101/android_notify/
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: pyjnius
-
-# Android Notify
-
-`android_notify` is a Python module designed to simplify sending Android notifications using Kivy and Pyjnius. It supports multiple notification styles, including text, images, and inbox layouts.
-
-## Features
-
-- Send Android notifications with custom titles and messages.
-- Support for multiple notification styles:
-  - Big Text
-  - Big Picture
-  - Large Icon
-  - Inbox
-- Supports including images in notifications.
-- Compatible with Android 8.0+ (Notification Channels).
-- Customizable notification channels.
-
-## Installation
-
-This package is available on PyPI and can be installed via pip:
-
-```bash
-pip install android-notify
-```
-
-## **Dependencies**
-
-**Prerequisites:**  
-
-- Buildozer  
-- Kivy
-
-In your **`buildozer.spec`** file, ensure you include the following:
-
-```ini
-# Add pyjnius so it's packaged with the build
-requirements = python3,kivy,pyjnius
-
-# Add permission for notifications
-android.permissions = POST_NOTIFICATIONS
-
-# Required dependencies (write exactly as shown, no quotation marks)
-android.gradle_dependencies = androidx.core:core:1.6.0, androidx.core:core-ktx:1.15.0
-android.enable_androidx = True
-```
-
----
-
-### Example Notification
-
-```python
-from android_notify.core import send_notification
-
-# Send a basic notification
-send_notification("Hello", "This is a basic notification.")
-
-# Send a notification with an image
-send_notification(
-    title='Picture Alert!',
-    message='This notification includes an image.',
-    style='big_picture',
-    img_path='assets/imgs/icon.png'
-)
-
-# Send a notification with inbox style
-send_notification(
-    title='Inbox Notification',
-    message='Line 1\nLine 2\nLine 3',
-    style='inbox'
-)
-
-# Send a Big Text notification (Note this send as a normal notification if not supported on said device)
-send_notification(
-    title='Hello!',
-    message='This is a sample notification.',
-    style='big_text'
-)
-```
-
----
-
-### **Assist** -- How to Copy image to app folder
-
-```python
-import shutil # This module comes packaged with python
-from android.storage import app_storage_path # type: ignore -- This works only on android
-
-app_path = os.path.join(app_storage_path(),'app')
-image_path= "/storage/emulated/0/Download/profile.png"
-
-shutil.copy(image_path, os.path.join(app_path, "profile.png"))
-```
-
----
-
-### **Functions Reference**
-
-### 1. `asks_permission_if_needed()`
-
-**Description:**
-
-- Checks if notification permissions are granted and requests them if missing.
-
-**Usage:**
-
-```python
-asks_permission_if_needed()
-```
-
----
-
-### 2. `get_image_uri(relative_path)`
-
-**Description:**
-
-- Resolves the absolute URI for an image in the app's storage.
-
-**Parameters:**
-
-- `relative_path` *(str)*: Path to the image (e.g., `assets/imgs/icon.png`).
-
-**Returns:**
-
-- `Uri`: Android URI object for the image.
-
-**Usage:**
-
-```python
-uri = get_image_uri('assets/imgs/icon.png')
-```
-
----
-
-### 3. `send_notification(title, message, style=None, img_path=None, channel_id='default_channel')`
-
-**Description:**
-
-- Sends an Android notification with optional styles and images.
-
-**Parameters:**
-
-- `title` *(str)*: Notification title.
-- `message` *(str)*: Notification message.
-- `style` *(str, optional)*: Notification style (`big_text`, `big_picture`, `inbox`, `large_icon`).
-- `img_path` *(str, optional)*: Path to the image resource.(for `big_picture` or `large_icon` styles).
-- `channel_id` *(str, optional)*: Notification channel ID.
-
-Returns - notification id
-
-### Advanced Usage
-
-You can customize notification channels for different types of notifications.
-
-```python
-send_notification(
-    title='Custom Channel Notification',
-    message='This uses a custom notification channel.',
-    channel_id='custom_channel'
-)
-```
-
-## Contribution
-
-Feel free to open issues or submit pull requests for improvements!
-
-## 🐛 Reporting Issues
-
-Found a bug? Please open an issue on our [GitHub Issues](https://github.com/Fector101/android_notify/issues) page.
-
-## Author
-
-- Fabian - <fector101@yahoo.com>
-- GitHub: <https://github.com/Fector101/android_notify>
-
-For feedback or contributions, feel free to reach out!
-
----
-
-## ☕ Support the Project
-
-If you find this project helpful, consider buying me a coffee! Your support helps maintain and improve the project.
-
-<a href="https://www.buymeacoffee.com/fector101" target="_blank">
-  <img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="60">
-</a>
-
----
-
-## Acknowledgments
-
-- Thanks to the Kivy and Pyjnius communities for their support.
-
----
-
-## 🌐 **Links**
-
-- **PyPI:** [android-notify on PyPI](https://pypi.org/project/android-notify/)
-- **GitHub:** [Source Code Repository](hhttps://github.com/Fector101/android_notify/)

android_notify-1.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-android_notify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-android_notify/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-android_notify/core.py,sha256=P80jtB4Dim9c10ibgVPioEDJOKgjcoetl7rHAHEZEAI,5960
-android_notify/styles.py,sha256=P_8sAqb3Hbf_vbhqSoCVjKeqJ05Fr_CksO-HX5pj8pU,134
-android_notify-1.2.dist-info/METADATA,sha256=pkhzt6TaEZ1gTTEShVpXrATujLqcsVA-GQn3g7X65Qg,5125
-android_notify-1.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-android_notify-1.2.dist-info/top_level.txt,sha256=IR1ONMrRSRINZpWn2X0dL5gbWwWINsK7PW8Jy2p4fU8,15
-android_notify-1.2.dist-info/RECORD,,