android-notify 1.60.1__py3-none-any.whl → 1.60.2__py3-none-any.whl

android_notify-1.60.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+android-notify = android_notify.__main__:main

{android_notify-1.60.1.dist-info → android_notify-1.60.2.dist-info}/top_level.txt

@@ -1 +1,3 @@
 android_notify
+docs
+venv

docs/examples/flet-working/src/core.py

@@ -0,0 +1,221 @@
+""" Non-Advanced Stuff """
+import random
+import os
+ON_ANDROID = False
+
+def on_flet_app():
+    return os.getenv("MAIN_ACTIVITY_HOST_CLASS_NAME")
+
+def get_activity_class_name():
+    ACTIVITY_CLASS_NAME = os.getenv("MAIN_ACTIVITY_HOST_CLASS_NAME") # flet python
+    if not ACTIVITY_CLASS_NAME:
+        try:
+            from android import config
+            ACTIVITY_CLASS_NAME = getattr(config, "JAVA_NAMESPACE", None)
+        except (ImportError, AttributeError):
+            ACTIVITY_CLASS_NAME = 'org.kivy.android'
+    return ACTIVITY_CLASS_NAME
+
+try:
+
+    from jnius import autoclass # Needs Java to be installed
+    # Get the required Java classes
+    ACTIVITY_CLASS_NAME = get_activity_class_name()
+    PythonActivity = autoclass(ACTIVITY_CLASS_NAME)
+    context = PythonActivity.mActivity # Get the app's context 
+    NotificationChannel = autoclass('android.app.NotificationChannel')
+    String = autoclass('java.lang.String')
+    Intent = autoclass('android.content.Intent')
+    PendingIntent = autoclass('android.app.PendingIntent')
+    BitmapFactory = autoclass('android.graphics.BitmapFactory')
+    BuildVersion = autoclass('android.os.Build$VERSION')    
+    ON_ANDROID=True
+except Exception as e:
+    print('\nThis Package Only Runs on Android !!! ---> Check "https://github.com/Fector101/android_notify/" to see design patterns and more info.\n')
+
+if ON_ANDROID:
+    try:
+        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')
+        NotificationCompatBigPictureStyle = autoclass('androidx.core.app.NotificationCompat$BigPictureStyle')
+        NotificationCompatInboxStyle = autoclass('androidx.core.app.NotificationCompat$InboxStyle')
+    except Exception as e:
+        print("""\n
+        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\n
+        """)
+
+
+def get_app_root_path():
+    if on_flet_app():
+        return os.path.join(context.getFilesDir().getAbsolutePath(),'flet')
+    else:
+        from android.storage import app_storage_path # type: ignore
+        return app_storage_path()
+    
+def asks_permission_if_needed():
+    """
+    Ask for permission to send notifications if needed.
+    """
+    if on_flet_app():
+        VERSION_CODES = autoclass('android.os.Build$VERSION_CODES')
+        ContextCompat = autoclass('androidx.core.content.ContextCompat')
+        # if you get error `Failed to find class: androidx/core/app/ActivityCompat`
+        #in proguard-rules.pro add `-keep class androidx.core.app.ActivityCompat { *; }`
+        ActivityCompat = autoclass('androidx.core.app.ActivityCompat')
+        Manifest = autoclass('android.Manifest$permission')
+        VERSION_CODES = autoclass('android.os.Build$VERSION_CODES')
+
+        if BuildVersion.SDK_INT >= VERSION_CODES.TIRAMISU:
+            permission = Manifest.POST_NOTIFICATIONS
+            granted = ContextCompat.checkSelfPermission(context, permission)
+
+            if granted != 0:  # PackageManager.PERMISSION_GRANTED == 0
+                ActivityCompat.requestPermissions(context, [permission], 101)
+    else: # android package is from p4a which is for kivy
+        try:
+            from android.permissions import request_permissions, Permission,check_permission # type: ignore
+            permissions=[Permission.POST_NOTIFICATIONS]
+            if not all(check_permission(p) for p in permissions):
+                request_permissions(permissions)
+        except Exception as e:
+            print("android_notify- error trying to request notification access: ", e)
+
+def get_image_uri(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').
+    """
+    app_root_path = get_app_root_path() 
+    output_path = os.path.join(app_root_path,'app', relative_path)
+    # print(output_path,'output_path')  # /data/user/0/org.laner.lan_ft/files/app/assets/imgs/icon.png
+    
+    if not os.path.exists(output_path):
+        raise FileNotFoundError(f"\nImage not found at path: {output_path}\n")
+    
+    Uri = autoclass('android.net.Uri')
+    return Uri.parse(f"file://{output_path}")
+
+def get_icon_object(uri):
+    BitmapFactory = autoclass('android.graphics.BitmapFactory')
+    IconCompat = autoclass('androidx.core.graphics.drawable.IconCompat')
+
+    bitmap= BitmapFactory.decodeStream(context.getContentResolver().openInputStream(uri))
+    return IconCompat.createWithBitmap(bitmap)
+
+def insert_app_icon(builder,custom_icon_path):
+    if custom_icon_path:
+        try:
+            uri = get_image_uri(custom_icon_path)
+            icon = get_icon_object(uri)
+            builder.setSmallIcon(icon)
+        except Exception as e:
+            print('android_notify- error: ',e)
+            builder.setSmallIcon(context.getApplicationInfo().icon)
+    else:
+        print('Found res icon -->',context.getApplicationInfo().icon,'<--')
+        builder.setSmallIcon(context.getApplicationInfo().icon)
+
+def send_notification(
+    title:str,
+    message:str,
+    style=None,
+    img_path=None,
+    channel_name="Default Channel",
+    channel_id:str="default_channel",
+    custom_app_icon_path="",
+
+    big_picture_path='',
+    large_icon_path='',
+    big_text="",
+    lines=""
+    ):
+    """
+    Send a notification on Android.
+
+    :param title: Title of the notification.
+    :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.(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
+
+    # Notification Channel (Required for Android 8.0+)
+    if BuildVersion.SDK_INT >= 26:
+        channel = NotificationChannel(channel_id, channel_name,importance)
+        notification_manager.createNotificationChannel(channel)
+
+    # Build the notification
+    builder = NotificationCompatBuilder(context, channel_id)
+    builder.setContentTitle(title)
+    builder.setContentText(message)
+    insert_app_icon(builder,custom_app_icon_path)
+    builder.setDefaults(NotificationCompat.DEFAULT_ALL)
+    builder.setPriority(NotificationCompat.PRIORITY_HIGH)
+
+    if img_path:
+        print('android_notify- img_path arg deprecated use "large_icon_path or big_picture_path or custom_app_icon_path"instead ')
+
+    big_picture = None
+    if big_picture_path:
+        try:
+            big_picture = get_image_uri(big_picture_path)
+        except FileNotFoundError as e:
+            print('android_notify- Error Getting Uri for big_picture_path: ',e)
+
+    large_icon = None
+    if large_icon_path:
+        try:
+            large_icon = get_image_uri(large_icon_path)
+        except FileNotFoundError as e:
+            print('android_notify- Error Getting Uri for large_icon_path: ',e)
+
+
+    # Apply notification styles
+    try:
+        if big_text:
+            big_text_style = NotificationCompatBigTextStyle()
+            big_text_style.bigText(big_text)
+            builder.setStyle(big_text_style)
+
+        elif lines:
+            inbox_style = NotificationCompatInboxStyle()
+            for line in lines.split("\n"):
+                inbox_style.addLine(line)
+            builder.setStyle(inbox_style)
+
+        if large_icon:
+            bitmap = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(large_icon))
+            builder.setLargeIcon(bitmap)
+
+        if big_picture:
+            bitmap = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(big_picture))
+            builder.setLargeIcon(bitmap)
+            big_picture_style = NotificationCompatBigPictureStyle().bigPicture(bitmap)
+            builder.setStyle(big_picture_style)
+
+    except Exception as e:
+        print('android_notify- Error Failed Adding Style: ',e)
+    # Display the notification
+    notification_id = random.randint(0, 100)
+    notification_manager.notify(notification_id, builder.build())
+    return notification_id
+

docs/examples/flet-working/src/main.py

@@ -0,0 +1,68 @@
+import flet as ft
+import os,traceback
+
+
+md1 = """ """
+i=0
+
+def main(page: ft.Page): 
+    page.scroll = ft.ScrollMode.ADAPTIVE
+    mdObj=ft.Markdown(
+            md1,
+            selectable=True,
+            extension_set=ft.MarkdownExtensionSet.GITHUB_WEB,
+            on_tap_link=lambda e: page.launch_url(e.data),
+        )
+    def console(a):
+        global md1
+        try:
+            with open(os.getenv("FLET_APP_CONSOLE"), "r") as f:
+                md1 = f.read()
+                mdObj.value=md1
+        except Exception as e:
+            print(e,"hello readddd it's me")
+            mdObj.value=f"{e}, hello readddd it's me"
+        finally:
+            mdObj.update()
+
+    def send_basic(e):
+        
+        try:
+            from core import send_notification
+            send_notification(title='Hello World',message='From android_notify',custom_app_icon_path=f'assets/icon.png')
+        except Exception as e:
+            print("Error importing android_notify: {}".format(e))
+    
+    def log_stuff(e):
+        global i
+        i+=1
+        print('Testing print visiblity: ',i,'\n')
+        console(None)
+
+    def request_permission(e):
+        try:
+            from core import asks_permission_if_needed
+            asks_permission_if_needed()
+        except Exception as e:
+            print( f"pyjnius android_ import error: {traceback.format_exc()}"            ) 
+
+    
+ 
+
+    page.add(
+        ft.OutlinedButton(
+            "Request Permission if Needed",
+            on_click=request_permission,
+        ), ft.OutlinedButton(
+            "Refresh Prints",
+            on_click=console,
+        ), ft.OutlinedButton(
+            "Testing print visiblity",
+            on_click=log_stuff,
+        )
+    )
+    btn = ft.ElevatedButton("Click me!", on_click=send_basic)
+    page.add(btn)
+    page.add(mdObj)
+
+ft.app(main)

docs/tests/flet/adv/main.py

@@ -0,0 +1,97 @@
+import os,traceback,io,sys,unittest
+import flet as ft
+from contextlib import redirect_stdout
+from android_notify.core import get_app_root_path,asks_permission_if_needed
+
+md1=''
+i=0
+def main(page: ft.Page):
+    page.scroll = ft.ScrollMode.ADAPTIVE
+    page.add(ft.Text("1111111111 Android Notify Test Results", size=24, weight=ft.FontWeight.BOLD))
+    logs_path=os.path.join(get_app_root_path(),'last.txt')
+    mdObj = ft.Markdown(
+        md1,
+        selectable=True,
+        extension_set=ft.MarkdownExtensionSet.GITHUB_WEB,
+        on_tap_link=lambda e: page.launch_url(e.data),
+    )
+    page.add(mdObj)
+    def console(a):
+        global md1,i
+        i+=1
+        print('Testing print visibility: ',i,'\n')
+        try:
+            if os.getenv("FLET_APP_CONSOLE"):
+                with open(os.getenv("FLET_APP_CONSOLE"), "r") as f:
+                    md1 = f.read()
+                    mdObj.value = md1
+
+            with open(logs_path, 'r') as logf:
+                mdObj.value = logf.read() + md1
+        except Exception as err:
+            mdObj.value = f"Error reading log: {err}"
+        finally:
+            mdObj.update()
+
+
+    def send_basic(e):
+        """Send a notification to verify android_notify works"""
+        try:
+            from android_notify import Notification
+            Notification(title="Hello World", message="From android_notify").send()
+        except Exception as err:
+            mdObj.value = f"Notification error: {err}"
+            mdObj.update()
+    def asks_permission_if_needed_(e):
+        asks_permission_if_needed()
+
+
+    def ensure_tests_folder():
+        try:
+            base_path = get_app_root_path()
+        except Exception:
+            base_path = os.path.dirname(__file__)
+
+        tests_path = os.path.join(base_path, "tests")
+        os.makedirs(tests_path, exist_ok=True)
+        init_file = os.path.join(tests_path, "__init__.py")
+        if not os.path.exists(init_file):
+            open(init_file, "w").close()
+
+        page.add(ft.Text(f"{tests_path}", size=24, weight=ft.FontWeight.BOLD))
+        return tests_path
+
+    page.add(ft.Text("2222222222 Android Notify Test Results", size=24, weight=ft.FontWeight.BOLD))
+
+    def run_tests(e=None):
+        """Run tests and log results to /sdcard/flet_app_console.txt"""
+        tests_path = ensure_tests_folder()
+
+        try:
+            with open(logs_path, "w") as logf, redirect_stdout(logf):
+                loader = unittest.TestLoader()
+                suite = loader.discover(start_dir=tests_path, pattern="test_*.py")
+                print("Discovered tests:",suite.countTestCases())
+                if suite.countTestCases() ==0:
+                    print("No tests found")
+
+
+                runner = unittest.TextTestRunner(stream=logf, verbosity=2)
+                runner.run(suite)
+
+            mdObj.value = f"Tests complete. Log saved to:\n`{logs_path}`"
+        except Exception as err:
+            mdObj.value = f"Test error:\n{traceback.format_exc()}"
+        mdObj.update()
+    def has_per(e=None):
+        from android_notify import NotificationHandler
+        print('permmm:',NotificationHandler.has_permission())
+    page.add(
+        ft.OutlinedButton("🔔 Send Basic Notification", on_click=send_basic),
+        ft.OutlinedButton("🔁 Refresh Prints", on_click=console),
+        ft.OutlinedButton("🧪 Run Tests", on_click=run_tests),
+        ft.OutlinedButton("🧪permmm", on_click=has_per),
+        ft.OutlinedButton("🧪asks_permission_if_needed", on_click=asks_permission_if_needed_),
+    )
+
+ft.app(main)

docs/tests/flet/adv/tests/test_android_notify_full.py

@@ -0,0 +1,199 @@
+"""
+Comprehensive test suite for Android-Notify Tester (Laner.use_android_notify)
+Covers all notification styles, callbacks, and behaviors.
+"""
+import unittest
+import time
+import traceback
+
+from android_notify import Notification, NotificationStyles, NotificationHandler, send_notification
+
+
+class TestAndroidNotifyFull(unittest.TestCase):
+    def tearDown(self):
+        time.sleep(3)
+
+    def setUp(self):
+        max_int = 2_147_483_647
+        self.uid = int(time.time() * 1000) % max_int
+
+    def test_simple(self):
+        try:
+            n = Notification( id=self.uid,title="Simple", message="Simple message test")
+            n.send()
+        except Exception as e:
+            self.fail(f"Simple notification failed: {e}")
+
+    def test_progress(self):
+        try:
+            n = Notification( id=self.uid,title="Downloading...", message="0% downloaded", progress_current_value=0, progress_max_value=100)
+            n.send()
+            for i in range(0, 101, 10):
+                time.sleep(2)
+                n.updateProgressBar(i, f"{i}% done")
+            n.removeProgressBar(message="Done", title="Download Complete")
+        except Exception as e:
+            self.fail(f"Progress notification failed: {e}")
+
+    def test_big_picture(self):
+        try:
+            n = Notification( id=self.uid,title="Big Picture", message="Testing big picture")
+            n.setBigPicture("assets/icon.png")
+            n.send()
+        except Exception as e:
+            self.fail(f"Big picture failed: {e}")
+
+    def test_inbox(self):
+        try:
+            n = Notification( id=self.uid,title="Inbox", message="Inbox notification")
+            n.setLines(["Line 1", "Line 2", "Line 3"])
+            n.send()
+        except Exception as e:
+            self.fail(f"Inbox notification failed: {e}")
+
+    def test_inbox_from_file_message(self):
+        try:
+            lines = "Test1\nTest2\nTest3"
+            n = Notification( id=self.uid,title="Inbox File", message="File Inbox Test", lines_txt=lines)
+            n.send()
+        except Exception as e:
+            self.fail(f"Inbox from file failed: {e}")
+
+    def test_inbox_add_line(self):
+        try:
+            n = Notification( id=self.uid,title="Inbox AddLine", message="Testing addLine()")
+            n.addLine("First line")
+            n.addLine("Second line")
+            n.addLine("Third line")
+            n.send()
+        except Exception as e:
+            self.fail(f"Inbox addLine failed: {e}")
+
+    def test_large_icon(self):
+        try:
+            n = Notification( id=self.uid,title="Large Icon", message="Testing large icon")
+            n.setLargeIcon("assets/icon.png")
+            n.send()
+        except Exception as e:
+            self.fail(f"Large icon failed: {e}")
+
+    def test_big_text(self):
+        try:
+            n = Notification( id=self.uid,title="Big Text", message="Testing big text")
+            n.setBigText("Lorem Ipsum is dummy text for testing BigTextStyle display.")
+            n.send()
+        except Exception as e:
+            self.fail(f"Big text failed: {e}")
+
+    def test_buttons(self):
+        try:
+            n = Notification( id=self.uid,title="With Buttons", message="Testing action buttons")
+            n.addButton(text="Play", on_release=lambda: print("Playing"))
+            n.addButton(text="Pause", on_release=lambda: print("Paused"))
+            n.addButton(text="Stop", on_release=lambda: print("Stopped"))
+            n.send()
+        except Exception as e:
+            self.fail(f"Buttons failed: {e}")
+
+    def test_both_imgs(self):
+        try:
+            n = Notification( id=self.uid,title="Both Images", message="Testing both large & big picture")
+            n.setLargeIcon("assets/icon.png")
+            n.setBigPicture("assets/icon.png")
+            n.send()
+        except Exception as e:
+            self.fail(f"Both imgs failed: {e}")
+
+    def test_custom_icon(self):
+        try:
+            n = Notification( id=self.uid,title="Custom Icon", message="Testing custom app icon")
+            n.setSmallIcon("assets/icon.png")
+            n.send()
+        except Exception as e:
+            self.fail(f"Custom icon failed: {e}")
+
+    def test_title_message_update(self):
+        try:
+            n = Notification( id=self.uid,title="Old Title", message="Old Message")
+            n.send()
+            time.sleep(2)
+            n.updateTitle("New Title")
+            n.updateMessage("New Message")
+        except Exception as e:
+            self.fail(f"Update title/message failed: {e}")
+
+    def test_download_channel(self):
+        try:
+            n = Notification( id=self.uid,
+                title="Download Done",
+                message="Your file finished downloading.",
+                channel_name="Download Notifications",
+                channel_id="downloads_notifications"
+            )
+            n.send()
+        except Exception as e:
+            self.fail(f"Download channel failed: {e}")
+
+    def test_channel_generate_id(self):
+        try:
+            n = Notification( id=self.uid,
+                title="Generated Channel",
+                message="Channel creation test",
+                channel_name="Custom Channel"
+            )
+            n.send()
+        except Exception as e:
+            self.fail(f"Channel generating ID failed: {e}")
+
+    def test_custom_id(self):
+        try:
+            n = Notification( id=self.uid,title="Custom ID", message="Click to trigger handler", name="change_app_page")
+            n.send()
+        except Exception as e:
+            self.fail(f"Custom ID failed: {e}")
+
+    def test_callback(self):
+        try:
+            n = Notification( id=self.uid,title="With Callback", message="Tap to run callback", callback=lambda: print("Callback invoked"))
+            n.send()
+        except Exception as e:
+            self.fail(f"Callback failed: {e}")
+
+    def test_custom_channel_name(self):
+        try:
+            n = Notification( id=self.uid,title="Custom Channel", message="Testing custom name", channel_name="MyChannelName")
+            n.send()
+        except Exception as e:
+            self.fail(f"Custom channel name failed: {e}")
+
+    def test_cancel_all(self):
+        try:
+            Notification.cancelAll()
+        except Exception as e:
+            self.fail(f"Cancel all failed: {e}")
+
+    def test_create_channel_lifespan(self):
+        try:
+            n = Notification( id=self.uid,title="Check ID Lifespan", message="Testing channel id reuse")
+            cid = "test_channel_id"
+            n.createChannel(id=cid, name="Test Channel", description="Lifespan check")
+            n.send()
+        except Exception as e:
+            self.fail(f"Create channel lifespan failed: {e}")
+
+    def test_persistent(self):
+        try:
+            n = Notification( id=self.uid,title="Persistent", message="This notification should persist")
+            n.send(persistent=True)
+        except Exception as e:
+            self.fail(f"Persistent notification failed: {e}")
+
+    # def test_get_active_notifications(self):
+    #     try:
+    #         Notification( id=self.uid,).get_active_notifications()
+    #     except Exception as e:
+    #         self.fail(f"Get active notifications failed: {e}")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)