Пример #1
0
        private static void BindNotificationSafeHandle(Notification notification)
        {
            IntPtr            ptr;
            NotificationError ret;

            if (notification.Handle != null && notification.Handle.IsInvalid == false)
            {
                notification.Handle.Dispose();
            }

            if (notification.IsOngoing == true || notification.Progress != null)
            {
                ptr = Interop.Notification.Create(NotificationType.Ongoing);
            }
            else
            {
                ptr = Interop.Notification.Create(NotificationType.Basic);
            }

            if (ptr == IntPtr.Zero)
            {
                ret = (NotificationError)Tizen.Internals.Errors.ErrorFacts.GetLastResult();
                throw NotificationErrorFactory.GetException(ret, "Unable to create IntPtr Notification");
            }

            notification.Handle = new NotificationSafeHandle(ptr, true);
        }
Пример #2
0
        internal static void BindObject(Notification notification)
        {
            int flag;
            NotificationError ret = NotificationError.None;

            Notification.IndicatorStyle style = (Notification.IndicatorStyle)notification.GetStyle("Indicator");
            Interop.Notification.GetApplist(notification.Handle, out flag);

            if (string.IsNullOrEmpty(style.SubText) == false)
            {
                ret = Interop.Notification.SetText(notification.Handle, NotificationText.FirstMainText, style.SubText, null, -1);
                if (ret != NotificationError.None)
                {
                    throw NotificationErrorFactory.GetException(ret, "unable to set indicator text");
                }
                flag |= (int)NotificationDisplayApplist.Ticker;
            }

            if (string.IsNullOrEmpty(style.IconPath) == false)
            {
                ret = Interop.Notification.SetImage(notification.Handle, NotificationImage.IconForIndicator, style.IconPath);
                if (ret != NotificationError.None)
                {
                    throw NotificationErrorFactory.GetException(ret, "unable to set indicator image");
                }
                flag |= (int)NotificationDisplayApplist.Indicator;
            }
            Interop.Notification.SetApplist(notification.Handle, flag);
        }
Пример #3
0
        private static void BindLedToHandle(Notification notification)
        {
            NotificationError ret = NotificationError.None;

            Notification.AccessorySet accessory = notification.Accessory;

            ret = Interop.Notification.SetLed(notification.Handle, accessory.LedOption, 0);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "unable to set led");
            }

            ret = Interop.Notification.SetLedTimePeriod(notification.Handle, accessory.LedOnMillisecond, accessory.LedOffMillisecond);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "unable to set led period");
            }

            if (notification.Accessory.LedOption == AccessoryOption.Custom)
            {
                Color color = accessory.LedColor;
                ret = Interop.Notification.SetLed(notification.Handle, AccessoryOption.Custom, color.GetArgb());
                if (ret != NotificationError.None)
                {
                    throw NotificationErrorFactory.GetException(ret, "unable to set led color");
                }
            }
        }
Пример #4
0
        /// <summary>
        /// Searches for a posted notification which has the specified tag and has not been deleted yet.
        /// </summary>
        /// <remarks>
        /// Load method should be called only for notifications, which have been posted using the NotificationManager.Post method.
        /// If two or more notifications share the same tag, the notification posted most recently is returned.
        /// </remarks>
        /// <param name="tag">Tag used to query.</param>
        /// <returns>Notification Object with specified tag.</returns>
        /// <exception cref="ArgumentException">Throwing the same exception when argument is invalid and when the tag does not exist is misleading.</exception>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of permission denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        /// NotificationManager.Post(notification);
        ///
        ///     // do someting
        ///
        /// Notification loadNotification = NotificationManager.Load("first notification");
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static Notification Load(string tag)
        {
            IntPtr ptr = IntPtr.Zero;

            if (string.IsNullOrEmpty(tag))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }

            ptr = Interop.Notification.Load(tag);

            if (ptr == IntPtr.Zero)
            {
                NotificationError ret = (NotificationError)Tizen.Internals.Errors.ErrorFacts.GetLastResult();
                Log.Error(Notification.LogTag, "unable to load Notification : " + ret.ToString());
                if (ret == NotificationError.DbError)
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "the tag does not exist");
                }
                else
                {
                    throw NotificationErrorFactory.GetException(ret, "unable to load Notification");
                }
            }

            Notification notification = new Notification
            {
                Handle = new NotificationSafeHandle(ptr, true)
            }.Build();

            return(notification);
        }
Пример #5
0
        /// <summary>
        /// Posts a new notification.
        /// </summary>
        /// <param name="notification">Notification to post.</param>
        /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of a permission is denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        ///
        /// Notification.AccessorySet accessory = new Notification.AccessorySet
        /// {
        ///     SoundOption = AccessoryOption.On,
        ///     CanVibrate = true
        /// };
        /// notification.Accessory = accessory;
        ///
        ///     // do something
        ///
        /// NotificationManager.Post(notification);
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static void Post(Notification notification)
        {
            if (notification == null)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid argument to post method");
            }

            notification.Make();

            if (ResponseEventHandler != null && ResponseEventHandler.GetInvocationList().Length > 0)
            {
                NotificationError ret = Interop.Notification.PostWithEventCallback(notification.Handle, responseEventCallback, IntPtr.Zero);
                if (ret != NotificationError.None)
                {
                    throw NotificationErrorFactory.GetException(ret, "post notification with event callback failed");
                }
            }
            else
            {
                NotificationError ret = Interop.Notification.Post(notification.Handle);
                if (ret != NotificationError.None)
                {
                    throw NotificationErrorFactory.GetException(ret, "post notification failed");
                }
            }

            int priv_id, group_id;

            Interop.Notification.GetID(notification.Handle, out group_id, out priv_id);
            notification.PrivID = priv_id;
        }
Пример #6
0
        /// <summary>
        /// Loads a notification template from the notification database.
        /// </summary>
        /// <param name="name">Template name.</param>
        /// <returns>Notification Object with inputted template name.</returns>
        /// <exception cref="ArgumentException">Throwing the same exception when argument is invalid and when the template does not exist is misleading.</exception>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of permission denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        ///
        /// Notification.Accessory accessory = new Notification.Accessory
        /// {
        ///     LedOption = AccessoryOption.On,
        ///     VibrationOption = AccessoryOption.Custom,
        ///     VibrationPath = "vibration absolute path"
        /// }
        /// notification.setAccessory(accessory);
        ///
        ///     // do something
        ///
        /// NotificationManager.Post(notification);
        ///
        /// Notification.LockStyle style = new Notification.LockStyle
        /// {
        ///     IconPath = "icon path",
        ///     ThumbnailPath = "Thumbnail path"
        /// }
        /// notification.AddStyle(style);
        /// NotificationManager.SaveTemplate(notification, "firstTemplate");
        /// Notification notificationTemplate = NotificationManager.LoadTemplate("firstTemplate");
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static Notification LoadTemplate(string name)
        {
            IntPtr handle = IntPtr.Zero;

            if (string.IsNullOrEmpty(name))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid argument to load template");
            }

            handle = Interop.Notification.LoadTemplate(name);
            if (handle == IntPtr.Zero)
            {
                NotificationError ret = (NotificationError)Tizen.Internals.Errors.ErrorFacts.GetLastResult();
                if (ret == NotificationError.DbError)
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "the name does not exist");
                }
                else
                {
                    throw NotificationErrorFactory.GetException(ret, "unable to create Notification from template");
                }
            }

            Notification notification = new Notification
            {
                Handle = new NotificationSafeHandle(handle, true)
            }.Build();

            return(notification);
        }
Пример #7
0
            /// <summary>
            /// Method to set time to hide or delete notification.
            /// </summary>
            /// <remarks>
            /// The time settings for hiding and deleting are only reflected on the Tizen TV.
            /// If you use this API on other profile, this time settings have no effect.
            /// </remarks>
            /// <param name="hideTime">The value in seconds when the notification can be hidden from the notification viewer after the notification is posted.</param>
            /// <param name="deleteTime">The value in seconds when the notification can be deleted from the notification list in setting application after notification is posted.</param>
            /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
            /// <since_tizen> 3 </since_tizen>
            public void SetRemoveTime(int hideTime, int deleteTime)
            {
                if (hideTime < 0 || deleteTime < 0)
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid argument");
                }

                hideTimeout   = hideTime;
                deleteTimeout = deleteTime;
            }
Пример #8
0
        public static NotificationSafeHandle MakeNotificationSafeHandle(Notification notification)
        {
            if (notification == null)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid notification object");
            }

            notification.Make();

            return(notification.Handle);
        }
Пример #9
0
        public static Notification MakeNotification(NotificationSafeHandle handle)
        {
            if (handle == null || handle.IsInvalid == true)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "handle is invalid or null");
            }

            Notification notification = new Notification {
                Handle = handle
            }.Build();

            return(notification);
        }
Пример #10
0
        /// <summary>
        /// Method to remove style you already added.
        /// </summary>
        /// <typeparam name="T">Type of notification style to be queried.</typeparam>
        /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
        /// <since_tizen> 3 </since_tizen>
        public void RemoveStyle <T>() where T : Notification.StyleBase, new()
        {
            T type = new T();

            if (styleDictionary.ContainsKey(type.Key))
            {
                styleDictionary.Remove(type.Key);
            }
            else
            {
                Log.Error(LogTag, "Sytle Can't be removed, there is no style matched input key");
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }
        }
Пример #11
0
        /// <summary>
        /// Deletes a posted notification.
        /// </summary>
        /// <param name="notification">Notification to remove.</param>
        /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of a permission is denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        /// NotificationManager.Post(notification);
        ///
        ///     // do something
        ///
        /// NotificationManager.Delete(notification);
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <pre>
        /// Post method should be called on the notification object.
        /// </pre>
        /// <since_tizen> 3 </since_tizen>
        public static void Delete(Notification notification)
        {
            if (notification == null || notification.Handle == null || notification.Handle.IsInvalid)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid argument to post method");
            }

            NotificationError ret = Interop.Notification.Delete(notification.Handle);

            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "delete notification failed");
            }
        }
Пример #12
0
        /// <summary>
        /// Gets notification block state.
        /// </summary>
        /// <remarks>
        /// The user can set the notification block state in settings.
        /// The block state indicates whether or not notifications can be posted.
        /// Additionally, only notifications to the notification panel are allowed in "Do not disturb mode".
        /// Sound, vibrate, and active notifications are blocked.
        /// </remarks>
        /// <returns>NotificationBlockState is a state if notification is posted.</returns>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of a permission is denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static NotificationBlockState GetBlockState()
        {
            NotificationBlockState state;
            NotificationError      ret;

            ret = Interop.Notification.GetBlockState(out state);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "GetBlockState failed");
            }

            Log.Info(Notification.LogTag, "Current block state is " + state.ToString());
            return(state);
        }
Пример #13
0
            /// <summary>
            /// Gets the ButtonAction of the active notification.
            /// </summary>
            /// <param name="index">The index to get a button you already added.</param>
            /// <returns>The ButtonAction object, which you already added.</returns>
            /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
            /// <since_tizen> 3 </since_tizen>
            public ButtonAction GetButtonAction(ButtonIndex index)
            {
                ButtonAction button = null;

                if (buttonDictionary.ContainsKey(index) == true)
                {
                    buttonDictionary.TryGetValue(index, out button);
                }
                else
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "The value is not existed.");
                }

                return(button);
            }
Пример #14
0
        /// <summary>
        /// Method to get extra data you already set.
        /// </summary>
        /// <param name="key">The key of the extra data to get.</param>
        /// <returns>Bundle Object that include extra data</returns>
        /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
        /// <since_tizen> 4 </since_tizen>
        public Bundle GetExtraData(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }

            Bundle bundle;

            if (extraDataDictionary.TryGetValue(key, out bundle) == false)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered : " + key);
            }

            return(bundle);
        }
Пример #15
0
        /// <summary>
        /// Removes all posted notifications of calling application.
        /// </summary>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of a permission is denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <example>
        /// <code>
        /// Notification firstNotification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        /// NotificationManager.Post(firstNotification);
        ///
        /// Notification secondNotification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "second notification"
        /// };
        /// NotificationManager.Post(secondNotification);
        /// NotificationManager.DeleteAll();
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static void DeleteAll()
        {
            NotificationError ret;

            ret = Interop.Notification.DeleteAll((int)NotificationType.Basic);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "delete all notifications failed of Noti type");
            }

            ret = Interop.Notification.DeleteAll((int)NotificationType.Ongoing);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "delete all notifications failed of Ongoing type");
            }
        }
Пример #16
0
        private static void BindSoundToHandle(Notification notification)
        {
            Notification.AccessorySet accessory = notification.Accessory;

            if (accessory.SoundOption == AccessoryOption.Custom && string.IsNullOrEmpty(accessory.SoundPath))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "If the option is set to Custom, the path must also be set.");
            }

            NotificationError ret = Interop.Notification.SetSound(notification.Handle, accessory.SoundOption, accessory.SoundPath);

            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "unable to set sound");
            }
        }
Пример #17
0
        /// <summary>
        /// Saves a notification template to the notification database.
        /// </summary>
        /// <param name="notification">Notification to save as template.</param>
        /// <param name="name">Template name.</param>
        /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of a permission is denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown when it can't be saved as a template.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        ///
        /// Notification.Accessory accessory = new Notification.Accessory
        /// {
        ///     LedOption = AccessoryOption.On,
        ///     VibrationOption = AccessoryOption.Custom,
        ///     VibrationPath = "vibration absolute path"
        /// }
        /// notification.setAccessory(accessory);
        ///
        ///     // do something
        ///
        /// NotificationManager.Post(notification);
        ///
        /// Notification.LockStyle style = new Notification.LockStyle
        /// {
        ///     IconPath = "icon path",
        ///     ThumbnailPath = "Thumbnail path"
        /// }
        /// notification.AddStyle(style);
        /// NotificationManager.SaveTemplate(notification, "firstTemplate");
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static void SaveTemplate(Notification notification, string name)
        {
            if (notification == null || string.IsNullOrEmpty(name))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid argument to save template");
            }

            notification.Make();

            NotificationError ret = Interop.Notification.SaveTemplate(notification.Handle, name);

            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "save as template failed");
            }
        }
Пример #18
0
        /// <summary>
        /// Method to remove extra you already added.
        /// </summary>
        /// <remarks>
        /// The type of extra data is bundle.
        /// </remarks>
        /// <param name="key">The key of the extra data to add.</param>
        /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
        /// <since_tizen> 4 </since_tizen>
        public void RemoveExtraData(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }

            if (extraDataDictionary.ContainsKey(key))
            {
                extraDataDictionary.Remove(key);
            }
            else
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }
        }
Пример #19
0
            /// <summary>
            /// Initializes a new instance of the <see cref="ProgressType"/> class.
            /// You must initialize category, current, and max value of the progress.
            /// </summary>
            /// <param name="category">The category of progress that appeared on notification.</param>
            /// <param name="current">The current value of the progress.</param>
            /// <param name="max">The max value of the progress.</param>
            /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
            /// <since_tizen> 3 </since_tizen>
            public ProgressType(ProgressCategory category, double current, double max)
            {
                if (IsNegativeNumber(current))
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "The current must be a positive integer.");
                }

                if (IsNegativeNumber(max))
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "The max must be a positive integer.");
                }

                Category        = category;
                ProgressCurrent = current;
                ProgressMax     = max;
            }
Пример #20
0
        internal StyleBase GetStyle(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "Key is null or empty");
            }

            StyleBase style = null;
            bool      ret   = styleDictionary.TryGetValue(key, out style);

            if (ret == false)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "The Style object matched input key is not existed");
            }

            return(style);
        }
Пример #21
0
        /// <summary>
        /// Method to get style you already added.
        /// </summary>
        /// <typeparam name="T">Type of notification style to be queried.</typeparam>
        /// <returns>
        /// The Notification.Style object associated with the given style.
        /// </returns>
        /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
        /// <since_tizen> 3 </since_tizen>
        public T GetStyle <T>() where T : Notification.StyleBase, new()
        {
            T         type  = new T();
            StyleBase style = null;

            styleDictionary.TryGetValue(type.Key, out style);

            if (style == null)
            {
                Log.Error(LogTag, "Invalid Style");
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }
            else
            {
                return(style as T);
            }
        }
Пример #22
0
        /// <summary>
        /// Method to set extra data to add extra data.
        /// </summary>
        /// <remarks>
        /// The type of extra data is bundle.
        /// </remarks>
        /// <param name="key">The key of the extra data you want to add.</param>
        /// <param name="value">The value you want to add.</param>
        /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "Notification",
        ///     Content = "Hello Tizen",
        ///     Icon = "Icon path",
        /// };
        ///
        /// Bundle bundle = new Bundle();
        /// bundle.AddItem("key", "value");
        ///
        /// notification.SetExtraData("firstKey", bundle);
        /// </code>
        /// </example>
        /// <since_tizen> 4 </since_tizen>
        public void SetExtraData(string key, Bundle value)
        {
            if (value == null || value.SafeBundleHandle.IsInvalid || string.IsNullOrEmpty(key))
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }

            if (extraDataDictionary.ContainsKey(key) == true)
            {
                Log.Info(LogTag, "The key is existed, so extender data is replaced");
                extraDataDictionary.Remove(key);
                extraDataDictionary.Add(key, value);
            }
            else
            {
                extraDataDictionary.Add(key, value);
            }
        }
Пример #23
0
        /// <summary>
        /// Method for adding various styles to be applied to notification.
        /// </summary>
        /// <remarks>
        /// The user always see about valid notification style. If you add a style which is not supported in platform,
        /// this method has no effect.
        /// </remarks>
        /// <param name="style">The style to be applied to notification.</param>
        /// <exception cref="ArgumentException">Thrown when argument is invalid.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "Notification",
        ///     Content = "Hello Tizen",
        ///     Icon = "Icon path",
        ///     Count = 3
        /// };
        ///
        /// Notification.LockStyle lockStyle = new Notification.LockStyle
        /// {
        ///     IconPath = "Icon path",
        ///     ThumbnailPath = "Thumbnail Path"
        /// };
        ///
        /// notification.AddStyle(lockStyle);
        ///
        /// NotificationManager.Post(notification);
        /// </code>
        /// </example>
        /// <since_tizen> 3 </since_tizen>
        public void AddStyle(StyleBase style)
        {
            if (style == null)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid parameter entered");
            }

            if (styleDictionary.ContainsKey(style.Key) == true)
            {
                Log.Info(LogTag, "The Style is existed, so extender data is replaced");
                styleDictionary.Remove(style.Key);
                styleDictionary.Add(style.Key, style);
            }
            else
            {
                styleDictionary.Add(style.Key, style);
            }
        }
Пример #24
0
        /// <summary>
        /// Posts a new notification.
        /// </summary>
        /// <param name="notification">Notification to post.</param>
        /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
        /// <exception cref="UnauthorizedAccessException">Thrown in case of a permission is denied.</exception>
        /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
        /// <example>
        /// <code>
        /// Notification notification = new Notification
        /// {
        ///     Title = "title",
        ///     Content = "content",
        ///     Icon = "absolute icon path",
        ///     Tag = "first notification"
        /// };
        ///
        /// Notification.AccessorySet accessory = new Notification.AccessorySet
        /// {
        ///     SoundOption = AccessoryOption.On,
        ///     CanVibrate = true
        /// };
        /// notification.Accessory = accessory;
        ///
        ///     // do something
        ///
        /// NotificationManager.Post(notification);
        /// </code>
        /// </example>
        /// <privilege>http://tizen.org/privilege/notification</privilege>
        /// <since_tizen> 3 </since_tizen>
        public static void Post(Notification notification)
        {
            if (notification == null)
            {
                throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid argument to post method");
            }

            notification.Make();

            NotificationError ret = Interop.Notification.Post(notification.Handle);

            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "post notification failed");
            }

            int priv_id, group_id;

            Interop.Notification.GetID(notification.Handle, out group_id, out priv_id);
            notification.PrivID = priv_id;
        }
Пример #25
0
            /// <summary>
            /// Method to add a button to the active notification style.
            /// Buttons are displayed on the notification.
            /// </summary>
            /// <remarks>
            /// If you add button that has same index, the button is replaced to latest adding button.
            /// If you don't set an index on ButtonAction, the index is set sequentially from zero.
            /// </remarks>
            /// <param name="button">A ButtonAction for appear to the notification.</param>
            /// <exception cref="ArgumentException">Thrown when an argument is invalid.</exception>
            /// <example>
            /// <code>
            ///
            /// ButtonAction button = new ButtonAction
            /// {
            ///     Index = 0,
            ///     Text = "Yes"
            ///     Action = new AppControl{ ApplicationId = "org.tizen.app" };
            /// };
            ///
            /// ActiveStyle active = new ActiveStyle
            /// {
            ///     IsAutoRemove = true,
            ///     BackgroundImage = "image path",
            /// };
            ///
            /// active.AddButtonAction(button);
            ///
            /// </code>
            /// </example>
            /// <since_tizen> 3 </since_tizen>
            public void AddButtonAction(ButtonAction button)
            {
                if (button == null)
                {
                    throw NotificationErrorFactory.GetException(NotificationError.InvalidParameter, "invalid ButtonAction object");
                }

                if (button.Index == ButtonIndex.None)
                {
                    button.Index = (ButtonIndex)buttonDictionary.Count;
                    buttonDictionary.Add(button.Index, button);
                }
                else if (button.Index >= ButtonIndex.First)
                {
                    if (buttonDictionary.ContainsKey(button.Index))
                    {
                        buttonDictionary.Remove(button.Index);
                    }

                    buttonDictionary.Add(button.Index, button);
                }
            }
Пример #26
0
        internal static void BindObject(Notification notification)
        {
            int flag;
            NotificationError ret = NotificationError.None;

            Notification.LockStyle style = (Notification.LockStyle)notification.GetStyle("Lock");

            ret = Interop.Notification.SetImage(notification.Handle, NotificationImage.IconForLock, style.IconPath);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "unable to set lock icon");
            }

            ret = Interop.Notification.SetImage(notification.Handle, NotificationImage.ThumbnailForLock, style.ThumbnailPath);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "unable to set lock thumbnail");
            }

            Interop.Notification.GetApplist(notification.Handle, out flag);
            Interop.Notification.SetApplist(notification.Handle, flag | (int)NotificationDisplayApplist.Lock);
        }
Пример #27
0
        internal static void BindObject(Notification notification)
        {
            int flag;
            int hidetime          = 0;
            int deletetime        = 0;
            NotificationError ret = NotificationError.None;

            Notification.ActiveStyle style = (Notification.ActiveStyle)notification.GetStyle("Active");

            Interop.Notification.SetAutoRemove(notification.Handle, style.IsAutoRemove);

            style.GetRemoveTime(out hidetime, out deletetime);

            if (hidetime > 0)
            {
                Interop.Notification.SetHideTime(notification.Handle, hidetime);
            }

            if (deletetime > 0)
            {
                try
                {
                    Interop.Notification.SetDeleteTime(notification.Handle, deletetime);
                }
                catch (TypeLoadException)
                {
                    // To support in API version 3.0
                    style.SetRemoveTime(hidetime, 60);
                }
            }

            ret = Interop.Notification.SetImage(notification.Handle, NotificationImage.Background, style.BackgroundImage);
            if (ret != NotificationError.None)
            {
                throw NotificationErrorFactory.GetException(ret, "unable to set background Image");
            }

            if (style.DefaultButton != ButtonIndex.None)
            {
                Interop.Notification.SetDefaultButton(notification.Handle, (int)style.DefaultButton + 1);
            }

            Interop.Notification.GetApplist(notification.Handle, out flag);
            Interop.Notification.SetApplist(notification.Handle, flag | (int)NotificationDisplayApplist.Active);

            foreach (Notification.ButtonAction button in style.GetButtonAction())
            {
                button.Make(notification);
            }

            if (style.ReplyAction != null)
            {
                style.ReplyAction.Make(notification);
            }

            if (style.HiddenByUserAction != null)
            {
                Interop.Notification.SetExtensionAction(notification.Handle, NotificationEventType.HiddenByUser, style.HiddenByUserAction.SafeAppControlHandle);
            }

            if (style.HiddenByTimeoutAction != null)
            {
                Interop.Notification.SetExtensionAction(notification.Handle, NotificationEventType.HiddenByTimeout, style.HiddenByTimeoutAction.SafeAppControlHandle);
            }

            if (style.HiddenByExternalAction != null)
            {
                Interop.Notification.SetExtensionAction(notification.Handle, NotificationEventType.HiddenByExternal, style.HiddenByExternalAction.SafeAppControlHandle);
            }
        }