Exemple #1
0
        internal static void ThrowException(Interop.AppEvent.ErrorCode errorCode, string errorMessage = null,
                                            [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0)
        {
            Log.Error(LogTag, $"{memberName}({lineNumber.ToString()}) : {filePath}");

            switch (errorCode)
            {
            case Interop.AppEvent.ErrorCode.None:
                return;

            case Interop.AppEvent.ErrorCode.OutOfMemory:
            case Interop.AppEvent.ErrorCode.IoError:
                throw new InvalidOperationException(string.IsNullOrEmpty(errorMessage) ? "error code : " + errorCode.ToString() :
                                                    $"{errorMessage} - {errorCode}");

            case Interop.AppEvent.ErrorCode.InvalidParameter:
                Log.Error(LogTag, "Invalid parameter : " + errorMessage);
                throw new ArgumentException(string.IsNullOrEmpty(errorMessage) ? "Invalid parameter" : "Invalid parameter : " + errorMessage);

            case Interop.AppEvent.ErrorCode.PermissionDenied:
                Log.Error(LogTag, "Permission denied : " + errorMessage);
                throw new UnauthorizedAccessException(string.IsNullOrEmpty(errorMessage) ? "Permission denied" : "Permission denied : " + errorMessage);

            case Interop.AppEvent.ErrorCode.TimeOut:
                Log.Error(LogTag, "Timeout : " + errorMessage);
                throw new TimeoutException(string.IsNullOrEmpty(errorMessage) ? "Timeout" : "Timeout : " + errorMessage);

            default:
                Log.Error(LogTag, $"Unknown error : {errorMessage} - {errorCode}");
                throw new InvalidOperationException(string.IsNullOrEmpty(errorMessage) ? "Unknown error : " + errorCode.ToString() :
                                                    $"Unknown error : {errorMessage} - {errorCode}");
            }
        }
 /// <summary>
 /// Keeps last User-Event data for receiver applications.
 /// </summary>
 /// <param name="eventName">The event's name to send.</param>
 /// <remarks>The receiver applications will receive this last event data after adding their new handlers via ApplicationEventReceiver since the sender application called this method.
 /// If a sender application sends same event via trusted method and non-trusted method, then a trusted receiver will get latest data regardless of trusted or non-trusted,
 /// but non-trusted receiver will get the last data only from non-trusted method. The effect of this API continues during runtime.
 /// That means when the sender application process restarts, the sender application needs to call this api again to make the event to keep the last event.</remarks>
 /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception>
 /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
 /// <since_tizen> 6 </since_tizen>
 public static void KeepLastEvent(string eventName)
 {
     Interop.AppEvent.ErrorCode err = Interop.AppEvent.EventKeepLastEventData(eventName);
     if (err != Interop.AppEvent.ErrorCode.None)
     {
         ErrorFactory.ThrowException(err, "Keep last event");
     }
 }
 /// <summary>
 /// Sends the User-Event to receiver applications.
 /// </summary>
 /// <param name="eventName">The event's name to send.</param>
 /// <param name="eventData"> The event's data to send.</param>
 /// <remarks>The format of User-Event's name MUST be "event.{sender's appid}.{user-defined name}", refer to 'The name-format of User-Event' section,
 /// If the event_name is invalid, throw InvalidOperationException</remarks>
 /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception>
 /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
 /// <since_tizen> 6 </since_tizen>
 public static void Publish(string eventName, Bundle eventData)
 {
     Interop.AppEvent.ErrorCode err = Interop.AppEvent.EventPublishAppEvent(eventName, eventData.SafeBundleHandle);
     if (err != Interop.AppEvent.ErrorCode.None)
     {
         ErrorFactory.ThrowException(err, "Publish event");
     }
 }
 /// <summary>
 /// Sends the User-Event to trusted receiver-applications.
 /// </summary>
 /// <param name="eventName">The event's name to send.</param>
 /// <param name="eventData"> The event's data to send.</param>
 /// <param name="isTrusted"> Whether the event is trusted or not.</param>
 /// <remarks>The application which has same certification with sender can receive the event.
 /// The format of User-Event's name MUST be "event.{sender's appid}.{user-defined name}", refer to 'The name-format of User-Event' section,
 /// If the event_name is invalid, throw InvalidOperationException</remarks>
 /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception>
 /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception>
 /// <since_tizen> 6 </since_tizen>
 public static void Publish(string eventName, Bundle eventData, bool isTrusted)
 {
     if (isTrusted)
     {
         Interop.AppEvent.ErrorCode err = Interop.AppEvent.EventPublishTrustedAppEvent(eventName, eventData.SafeBundleHandle);
         if (err != Interop.AppEvent.ErrorCode.None)
         {
             ErrorFactory.ThrowException(err, "Publish trusted event");
         }
     }
     else
     {
         Publish(eventName, eventData);
     }
 }
Exemple #5
0
        /// <summary>
        /// Releases any unmanaged resources used by this object. Can also dispose any other disposable objects.
        /// </summary>
        /// <param name="disposing">If true, disposes any disposable objects. If false, does not dispose disposable objects.</param>
        /// <since_tizen> 6 </since_tizen>
        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                }

                if (eventHandler != null)
                {
                    Interop.AppEvent.ErrorCode err = Interop.AppEvent.EventRemoveHandler(_eventHandle);
                }

                disposedValue = true;
            }
        }