src/Tizen.Messaging/Tizen.Messaging.Messages/MessagesManagerImpl.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using System.Collections.Generic;
  19 using System.Threading.Tasks;
  20
  21 namespace Tizen.Messaging.Messages
  22 {
  23     static internal class Globals
  24     {
  25         internal const string LogTag = "Tizen.Messaging.Messages";
  26     }
  27
  28     internal partial class MessagesManagerImpl : IDisposable
  29     {
  30         private static readonly MessagesManagerImpl _instance = new MessagesManagerImpl();
  31         private bool disposed = false;
  32
  33         private static IntPtr _MessageServiceHandle;
  34
  35         private Interop.Messages.MessageSentCallback _messageSentCallback;
  36
  37         internal static MessagesManagerImpl Instance
  38         {
  39             get
  40             {
  41                 return _instance;
  42             }
  43         }
  44
  45         private MessagesManagerImpl()
  46         {
  47             initialize();
  48         }
  49
  50         ~MessagesManagerImpl()
  51         {
  52             Dispose(false);
  53         }
  54
  55         public void Dispose()
  56         {
  57             Dispose(true);
  58             GC.SuppressFinalize(this);
  59         }
  60
  61         private void Dispose(bool disposing)
  62         {
  63             if (disposed)
  64                 return;
  65
  66             if (disposing)
  67             {
  68                 // Free managed objects
  69             }
  70
  71             // Free unmanaged objects
  72             deinitialize();
  73             disposed = true;
  74         }
  75
  76         private void initialize()
  77         {
  78             int ret;
  79
  80             ret = Interop.Messages.OpenService(out _MessageServiceHandle);
  81             if (ret != (int)MessagesError.None)
  82             {
  83                 Log.Error(Globals.LogTag, "Failed to open service, Error - " + (MessagesError)ret);
  84                 MessagesErrorFactory.ThrowMessagesException(ret);
  85             }
  86         }
  87
  88         private void deinitialize()
  89         {
  90             if (_MessageServiceHandle != IntPtr.Zero)
  91             {
  92                 int ret;
  93
  94                 ret = Interop.Messages.CloseService(_MessageServiceHandle);
  95                 if (ret != (int)MessagesError.None)
  96                 {
  97                     Log.Error(Globals.LogTag, "Failed to close service, Error - " + (MessagesError)ret);
  98                 }
  99
 100                 _MessageServiceHandle = IntPtr.Zero;
 101             }
 102         }
 103
 104         internal Task<SentResult> SendMessageAsync(Message message, bool saveToSentbox)
 105         {
 106             var task = new TaskCompletionSource<SentResult>();
 107
 108             _messageSentCallback = (int result, IntPtr data) =>
 109             {
 110                 task.SetResult((SentResult)result);
 111             };
 112
 113             message.FillHandle();
 114
 115             int ret;
 116             IntPtr messageHandle = message.GetHandle();
 117
 118             ret = Interop.Messages.SendMessage(_MessageServiceHandle, messageHandle, saveToSentbox, _messageSentCallback, IntPtr.Zero);
 119             if (ret != (int)MessagesError.None)
 120             {
 121                 Log.Error(Globals.LogTag, "Failed to send message, Error - " + (MessagesError)ret);
 122                 MessagesErrorFactory.ThrowMessagesException(ret, _MessageServiceHandle);
 123             }
 124
 125             return task.Task;
 126         }
 127
 128         internal Task<IEnumerable<Message>> SearchMessageAsync(MessagesSearchFilter filter)
 129         {
 130             return Task.Run<IEnumerable<Message>>(() =>
 131             {
 132                 List<Message> messageList = new List<Message>();
 133                 int ret;
 134
 135                 Interop.Messages.MessageSearchCallback callback = (IntPtr messageHandle, int index, int resultCount, int totalCount, IntPtr userData) =>
 136                 {
 137                     try
 138                     {
 139                         if (messageHandle != IntPtr.Zero)
 140                         {
 141                             IntPtr duplicatedMessageHandle = IntPtr.Zero;
 142
 143                             DuplicateMessageHandle(messageHandle, out duplicatedMessageHandle);
 144                             if (duplicatedMessageHandle != IntPtr.Zero)
 145                             {
 146                                 int type = (int)MessageType.Unknown;
 147                                 int result = Interop.Messages.GetMessageType(duplicatedMessageHandle, out type);
 148                                 if (result != (int)MessagesError.None)
 149                                 {
 150                                     Log.Error(Globals.LogTag, "Failed to get message type, Error - " + (MessagesError)result);
 151                                 }
 152
 153                                 switch ((MessageType)type)
 154                                 {
 155                                     case MessageType.Sms:
 156                                     {
 157                                         var messageItem = new SmsMessage(duplicatedMessageHandle);
 158                                         messageList.Add(messageItem);
 159                                         break;
 160                                     }
 161                                     case MessageType.Mms:
 162                                     {
 163                                         var messageItem = new MmsMessage(duplicatedMessageHandle);
 164                                         messageList.Add(messageItem);
 165                                         break;
 166                                     }
 167                                     case MessageType.CellBroadcast:
 168                                     {
 169                                         var messageItem = new CBMessage(duplicatedMessageHandle);
 170                                         messageList.Add(messageItem);
 171                                         break;
 172                                     }
 173                                     case MessageType.Push:
 174                                     {
 175                                         var messageItem = new PushMessage(duplicatedMessageHandle);
 176                                         messageList.Add(messageItem);
 177                                         break;
 178                                     }
 179                                     default:
 180                                     {
 181                                         Log.Error(Globals.LogTag, "Invaild message type - " + type);
 182                                         break;
 183                                     }
 184                                 }
 185
 186                                 return true;
 187                             }
 188                         }
 189                     }
 190                     catch
 191                     {
 192                         Log.Error(Globals.LogTag, "Exception in Callback");
 193                     }
 194
 195                     return false;
 196                 };
 197
 198                 ret = Interop.Messages.SearchMessage(_MessageServiceHandle, (int)filter.MessageBoxType, (int)filter.MessageType, filter.TextKeyword, filter.AddressKeyword, 0, 0, callback, IntPtr.Zero);
 199                 if (ret != (int)MessagesError.None)
 200                 {
 201                     Log.Error(Globals.LogTag, "Failed to search message, Error - " + (MessagesError)ret);
 202                     MessagesErrorFactory.ThrowMessagesException(ret, _MessageServiceHandle);
 203                 }
 204
 205                 return messageList;
 206             });
 207         }
 208
 209         private void DuplicateMessageHandle(IntPtr sourceHandle, out IntPtr clonedHandle)
 210         {
 211             int msgId;
 212             IntPtr returnedHandle = IntPtr.Zero;
 213
 214             int ret = Interop.Messages.GetMessageId(sourceHandle, out msgId);
 215             if (ret == (int)MessagesError.None)
 216             {
 217                 ret = Interop.Messages.GetMessageById(_MessageServiceHandle, msgId, out returnedHandle);
 218                 if (ret != (int)MessagesError.None)
 219                 {
 220                     Log.Error(Globals.LogTag, "Failed to get message by id, Error - " + (MessagesError)ret);
 221                     MessagesErrorFactory.ThrowMessagesException(ret, _MessageServiceHandle);
 222                 }
 223             }
 224             else
 225             {
 226                 Log.Error(Globals.LogTag, "Failed to get message id, Error - " + (MessagesError)ret);
 227                 MessagesErrorFactory.ThrowMessagesException(ret, _MessageServiceHandle);
 228             }
 229
 230             clonedHandle = returnedHandle;
 231         }
 232     }
 233 }