Tizen.Messaging/Tizen.Messaging.Messages/Message.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.Collections.ObjectModel;
  20
  21 namespace Tizen.Messaging.Messages
  22 {
  23     /// <summary>
  24     /// A class to represent all messages.
  25     /// </summary>
  26     public abstract class Message : IDisposable
  27     {
  28         protected IntPtr _messageHandle = IntPtr.Zero;
  29         private bool disposed = false;
  30
  31         private ICollection<MessagesAddress> _from = new Collection<MessagesAddress>();
  32         protected ICollection<MessagesAddress> _to = new Collection<MessagesAddress>();
  33         protected ICollection<MessagesAddress> _cc = new Collection<MessagesAddress>();
  34         protected ICollection<MessagesAddress> _bcc = new Collection<MessagesAddress>();
  35
  36         protected Message(MessageType type)
  37         {
  38             int ret = Interop.Messages.CreateMessage((int)type, out _messageHandle);
  39             if (ret != (int)MessagesError.None)
  40             {
  41                 Log.Error(Globals.LogTag, "Failed to create message handle, Error - " + (MessagesError)ret);
  42                 MessagesErrorFactory.ThrowMessagesException(ret);
  43             }
  44         }
  45
  46         protected Message(IntPtr messageHandle)
  47         {
  48             _messageHandle = messageHandle;
  49             GetAllAddresses();
  50         }
  51
  52         internal void FillHandle()
  53         {
  54             SetAddresses();
  55             (this as MmsMessage)?.SetAttachments();
  56         }
  57
  58         ~Message()
  59         {
  60             Dispose(false);
  61         }
  62
  63         public void Dispose()
  64         {
  65             Dispose(true);
  66             GC.SuppressFinalize(this);
  67         }
  68
  69         private void Dispose(bool disposing)
  70         {
  71             if (disposed)
  72                 return;
  73
  74             if (disposing)
  75             {
  76                 // Free managed objects
  77             }
  78
  79             // Free unmanaged objects
  80             if (_messageHandle != IntPtr.Zero)
  81             {
  82                 Interop.Messages.DestroyMessage(_messageHandle);
  83                 _messageHandle = IntPtr.Zero;
  84             }
  85             disposed = true;
  86         }
  87
  88         internal IntPtr GetHandle()
  89         {
  90             return _messageHandle;
  91         }
  92
  93         private void SetAddresses()
  94         {
  95             foreach (var it in _to)
  96             {
  97                 AddAddress(it);
  98             }
  99
 100             foreach (var it in _cc)
 101             {
 102                 AddAddress(it);
 103             }
 104
 105             foreach (var it in _bcc)
 106             {
 107                 AddAddress(it);
 108             }
 109         }
 110
 111         private void AddAddress(MessagesAddress address)
 112         {
 113             int ret = Interop.Messages.AddAddress(_messageHandle, address.Number, (int)address.Type);
 114             if (ret != (int)MessagesError.None)
 115             {
 116                 Log.Error(Globals.LogTag, "Failed to add address, Error - " + (MessagesError)ret);
 117                 MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 118             }
 119         }
 120
 121         private void GetAllAddresses()
 122         {
 123             int count;
 124
 125             int ret = Interop.Messages.GetAddressCount(_messageHandle, out count);
 126             if (ret != (int)MessagesError.None)
 127             {
 128                 Log.Error(Globals.LogTag, "Failed to get address count, Error - " + (MessagesError)ret);
 129                 MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 130             }
 131
 132             string number;
 133             int type;
 134             var To = new Collection<MessagesAddress>();
 135             var Cc = new Collection<MessagesAddress>();
 136             var Bcc = new Collection<MessagesAddress>();
 137             var From = new Collection<MessagesAddress>();
 138
 139             for (int i = 0; i < count; i++)
 140             {
 141                 ret = Interop.Messages.GetAddress(_messageHandle, i, out number, out type);
 142                 if (ret != (int)MessagesError.None)
 143                 {
 144                     Log.Error(Globals.LogTag, "Failed to get address, Error - " + (MessagesError)ret);
 145                     MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 146                 }
 147
 148                 var addressItem = new MessagesAddress((RecipientType)type, number);
 149                 switch ((RecipientType)type)
 150                 {
 151                     case RecipientType.To:
 152                         To.Add(addressItem);
 153                         break;
 154                     case RecipientType.Cc:
 155                         Cc.Add(addressItem);
 156                         break;
 157                     case RecipientType.Bcc:
 158                         Bcc.Add(addressItem);
 159                         break;
 160                     default:
 161                         From.Add(addressItem);
 162                         break;
 163                 }
 164             }
 165
 166             _to = To;
 167             _cc = Cc;
 168             _bcc = Bcc;
 169             _from = From;
 170         }
 171
 172         public int Id
 173         {
 174             get
 175             {
 176                 int id = 0;
 177                 int ret = Interop.Messages.GetMessageId(_messageHandle, out id);
 178                 if (ret != (int)MessagesError.None)
 179                 {
 180                     Log.Error(Globals.LogTag, "Failed to get message id, Error - " + (MessagesError)ret);
 181                 }
 182
 183                 return id;
 184             }
 185         }
 186
 187         public int Port
 188         {
 189             get
 190             {
 191                 int port = 0;
 192                 int ret = Interop.Messages.GetMessagePort(_messageHandle, out port);
 193                 if (ret != (int)MessagesError.None)
 194                 {
 195                     Log.Error(Globals.LogTag, "Failed to get message port, Error - " + (MessagesError)ret);
 196                 }
 197
 198                 return port;
 199             }
 200         }
 201
 202         public MessageBoxType BoxType
 203         {
 204             get
 205             {
 206                 int boxType = (int)MessageBoxType.All;
 207                 int ret = Interop.Messages.GetMboxType(_messageHandle, out boxType);
 208                 if (ret != (int)MessagesError.None)
 209                 {
 210                     Log.Error(Globals.LogTag, "Failed to get message box type, Error - " + (MessagesError)ret);
 211                 }
 212
 213                 return (MessageBoxType)boxType;
 214             }
 215             set
 216             {
 217                 int ret = Interop.Messages.SetMboxType(_messageHandle, (int)value);
 218                 if (ret != (int)MessagesError.None)
 219                 {
 220                     Log.Error(Globals.LogTag, "Failed to set message box type, Error - " + (MessagesError)ret);
 221                     MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 222                 }
 223             }
 224         }
 225
 226         public string Text
 227         {
 228             get
 229             {
 230                 string text = null;
 231                 int ret = Interop.Messages.GetText(_messageHandle, out text);
 232                 if (ret != (int)MessagesError.None)
 233                 {
 234                     Log.Error(Globals.LogTag, "Failed to get text, Error - " + (MessagesError)ret);
 235                 }
 236
 237                 return text;
 238             }
 239             set
 240             {
 241                 int ret = Interop.Messages.SetText(_messageHandle, value);
 242                 if (ret != (int)MessagesError.None)
 243                 {
 244                     Log.Error(Globals.LogTag, "Failed to set text, Error - " + (MessagesError)ret);
 245                     MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 246                 }
 247             }
 248         }
 249
 250         public DateTime Time
 251         {
 252             get
 253             {
 254                 int time = 0;
 255                 int ret = Interop.Messages.GetTime(_messageHandle, out time);
 256                 if (ret != (int)MessagesError.None)
 257                 {
 258                     Log.Error(Globals.LogTag, "Failed to get time, Error - " + (MessagesError)ret);
 259                 }
 260
 261                 return (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).AddSeconds(time).ToLocalTime();
 262             }
 263             set
 264             {
 265                 int ret = Interop.Messages.SetTime(_messageHandle, (int)(value.ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds));
 266                 if (ret != (int)MessagesError.None)
 267                 {
 268                     Log.Error(Globals.LogTag, "Failed to set time, Error - " + (MessagesError)ret);
 269                     MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 270                 }
 271             }
 272         }
 273
 274         public SimSlotId SimId
 275         {
 276             get
 277             {
 278                 int simId = (int)SimSlotId.Unknown;
 279                 int ret = Interop.Messages.GetSimId(_messageHandle, out simId);
 280                 if (ret != (int)MessagesError.None)
 281                 {
 282                     Log.Error(Globals.LogTag, "Failed to get simId, Error - " + (MessagesError)ret);
 283                 }
 284
 285                 return (SimSlotId)simId;
 286             }
 287             set
 288             {
 289                 int ret = Interop.Messages.SetSimId(_messageHandle, (int)value);
 290                 if (ret != (int)MessagesError.None)
 291                 {
 292                     Log.Error(Globals.LogTag, "Failed to set simId, Error - " + (MessagesError)ret);
 293                     MessagesErrorFactory.ThrowMessagesException(ret, _messageHandle);
 294                 }
 295             }
 296         }
 297
 298         public IReadOnlyCollection<MessagesAddress> From
 299         {
 300             get
 301             {
 302                 return _from as IReadOnlyCollection<MessagesAddress>;
 303             }
 304         }
 305     }
 306 }