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