src/Tizen.CallManager/Tizen.CallManager/CmUtility.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 Tizen.Internals.Errors;
  19
  20 namespace Tizen.CallManager
  21 {
  22     internal enum CmError
  23     {
  24         None = ErrorCode.None,
  25         OutOfMemory = ErrorCode.OutOfMemory,
  26         InvalidParameter = ErrorCode.InvalidParameter,
  27         PermissionDenied = ErrorCode.PermissionDenied,
  28         NotSupported = ErrorCode.NotSupported,
  29         NotRegistered = -0x00000000 | 0x01,
  30         AlreadyRegistered = -0x00000000 | 0x02,
  31         OperationFailed = -0x00000000 | 0x03,
  32         InvalidState = -0x00000000 | 0x04
  33     }
  34
  35     internal static class CmUtility
  36     {
  37         internal const string LogTag = "Tizen.CallManager";
  38
  39         internal static CallData GetCallData(IntPtr handle)
  40         {
  41             CallData data = new CallData();
  42             int ret = Interop.CallManager.GetCallId(handle, out uint id);
  43             if (ret != (int)CmError.None)
  44             {
  45                 Log.Error(CmUtility.LogTag, "Failed to get call ID from call data, Error: " + (CmError)ret);
  46             }
  47
  48             else
  49             {
  50                 data.CallId = id;
  51             }
  52
  53             ret = Interop.CallManager.GetCallDirection(handle, out CallDirection direction);
  54             if (ret != (int)CmError.None)
  55             {
  56                 Log.Error(CmUtility.LogTag, "Failed to get call direction from call data, Error: " + (CmError)ret);
  57             }
  58
  59             else
  60             {
  61                 data.CallDirection = direction;
  62             }
  63
  64             ret = Interop.CallManager.GetCallNumber(handle, out string number);
  65             if (ret != (int)CmError.None)
  66             {
  67                 Log.Error(CmUtility.LogTag, "Failed to get call number from call data, Error: " + (CmError)ret);
  68             }
  69
  70             else
  71             {
  72                 data.Number = number;
  73             }
  74
  75             ret = Interop.CallManager.GetCallingName(handle, out string name);
  76             if (ret != (int)CmError.None)
  77             {
  78                 Log.Error(CmUtility.LogTag, "Failed to get calling name from call data, Error: " + (CmError)ret);
  79             }
  80
  81             else
  82             {
  83                 data.Name = name;
  84             }
  85
  86             ret = Interop.CallManager.GetCallType(handle, out CallType type);
  87             if (ret != (int)CmError.None)
  88             {
  89                 Log.Error(CmUtility.LogTag, "Failed to get call type from call data, Error: " + (CmError)ret);
  90             }
  91
  92             else
  93             {
  94                 data.CallType = type;
  95             }
  96
  97             ret = Interop.CallManager.GetCallState(handle, out CallState state);
  98             if (ret != (int)CmError.None)
  99             {
 100                 Log.Error(CmUtility.LogTag, "Failed to get call state from call data, Error: " + (CmError)ret);
 101             }
 102
 103             else
 104             {
 105                 data.CallState = state;
 106             }
 107
 108             ret = Interop.CallManager.GetCallMemberCount(handle, out int count);
 109             if (ret != (int)CmError.None)
 110             {
 111                 Log.Error(CmUtility.LogTag, "Failed to get call member count from call data, Error: " + (CmError)ret);
 112             }
 113
 114             else
 115             {
 116                 data.Count = count;
 117             }
 118
 119             ret = Interop.CallManager.IsEmergencyCall(handle, out bool isEmergency);
 120             if (ret != (int)CmError.None)
 121             {
 122                 Log.Error(CmUtility.LogTag, "Failed to check if the call is emergency from call data, Error: " + (CmError)ret);
 123             }
 124
 125             else
 126             {
 127                 data.IsEcc = isEmergency;
 128             }
 129
 130             ret = Interop.CallManager.IsVoiceMailNumber(handle, out bool isVoiceMail);
 131             if (ret != (int)CmError.None)
 132             {
 133                 Log.Error(CmUtility.LogTag, "Failed to check if the number is voicemail number from call data, Error: " + (CmError)ret);
 134             }
 135
 136             else
 137             {
 138                 data.IsVoiceMail = isVoiceMail;
 139             }
 140
 141             ret = Interop.CallManager.GetCallDomain(handle, out CallDomain domain);
 142             if (ret != (int)CmError.None)
 143             {
 144                 Log.Error(CmUtility.LogTag, "Failed to get call domain from call data, Error: " + (CmError)ret);
 145             }
 146
 147             else
 148             {
 149                 data.CallDomain = domain;
 150             }
 151
 152             ret = Interop.CallManager.GetPersonId(handle, out int personId);
 153             if (ret != (int)CmError.None)
 154             {
 155                 Log.Error(CmUtility.LogTag, "Failed to get person ID from call data, Error: " + (CmError)ret);
 156             }
 157
 158             else
 159             {
 160                 data.PersonIndex = personId;
 161             }
 162
 163             ret = Interop.CallManager.GetStartTime(handle, out long startTime);
 164             if (ret != (int)CmError.None)
 165             {
 166                 Log.Error(CmUtility.LogTag, "Failed to get start time from call data, Error: " + (CmError)ret);
 167             }
 168
 169             else
 170             {
 171                 data.CallStartTime = startTime;
 172             }
 173
 174             ret = Interop.CallManager.GetNameMode(handle, out CallNameMode nameMode);
 175             if (ret != (int)CmError.None)
 176             {
 177                 Log.Error(CmUtility.LogTag, "Failed to get name mode from call data, Error: " + (CmError)ret);
 178             }
 179
 180             else
 181             {
 182                 data.CallNameMode = nameMode;
 183             }
 184
 185             ret = Interop.CallManager.GetSessionId(handle, out int sessionId);
 186             if (ret != (int)CmError.None)
 187             {
 188                 Log.Error(CmUtility.LogTag, "Failed to get session ID from call data, Error: " + (CmError)ret);
 189             }
 190
 191             else
 192             {
 193                 data.SessionIdIms = sessionId;
 194             }
 195
 196             ret = Interop.CallManager.GetHdIconState(handle, out int isHdEnable);
 197             if (ret != (int)CmError.None)
 198             {
 199                 Log.Error(CmUtility.LogTag, "Failed to get HD icon state from call data, Error: " + (CmError)ret);
 200             }
 201
 202             else
 203             {
 204                 data.IsHdEnableIms = (isHdEnable == 1) ? true : false;
 205             }
 206
 207             ret = Interop.CallManager.IsWiFiCalling(handle, out int isWiFiCalling);
 208             if (ret != (int)CmError.None)
 209             {
 210                 Log.Error(CmUtility.LogTag, "Failed to identify WiFi calling from call data, Error: " + (CmError)ret);
 211             }
 212
 213             else
 214             {
 215                 data.IsWiFiCall = (isWiFiCalling == 1) ? true : false;
 216             }
 217
 218             ret = Interop.CallManager.GetUpgradeDowngradeState(handle, out int isEnable);
 219             if (ret != (int)CmError.None)
 220             {
 221                 Log.Error(CmUtility.LogTag, "Failed to get updagrade downgrade state from call data, Error: " + (CmError)ret);
 222             }
 223
 224             else
 225             {
 226                 data.IsUpgradeDowngrade = (isEnable == 1) ? true : false;
 227             }
 228
 229             ret = Interop.CallManager.IsRemoteOnHold(handle, out int isHold);
 230             if (ret != (int)CmError.None)
 231             {
 232                 Log.Error(CmUtility.LogTag, "Failed to get remote on hold state from call data, Error: " + (CmError)ret);
 233             }
 234
 235             else
 236             {
 237                 data.IsRemoteHold = (isHold == 1) ? true : false;
 238             }
 239
 240             ret = Interop.CallManager.IsAddedToConference(handle, out int isAdded);
 241             if (ret != (int)CmError.None)
 242             {
 243                 Log.Error(CmUtility.LogTag, "Failed to check if the call is in conf state from call data, Error: " + (CmError)ret);
 244             }
 245
 246             else
 247             {
 248                 data.IsAddedToConf = (isAdded == 1) ? true : false;
 249             }
 250
 251             ret = Interop.CallManager.IsForwardedCall(handle, out bool isForwarded);
 252             if (ret != (int)CmError.None)
 253             {
 254                 Log.Error(CmUtility.LogTag, "Failed to check if the call is forwarded call from call data, Error: " + (CmError)ret);
 255             }
 256
 257             else
 258             {
 259                 data.IsForwardedCall = isForwarded;
 260             }
 261
 262             return data;
 263         }
 264
 265         internal static ConferenceCallData GetConfCallData(IntPtr handle)
 266         {
 267             ConferenceCallData confData = new ConferenceCallData();
 268             int ret = Interop.CallManager.GetConfCallId(handle, out uint callId);
 269             if (ret != (int)CmError.None)
 270             {
 271                 Log.Error(CmUtility.LogTag, "Failed to get conf call ID, Error: " + (CmError)ret);
 272             }
 273
 274             else
 275             {
 276                 confData.CallId = callId;
 277             }
 278
 279             ret = Interop.CallManager.GetConfCallNumber(handle, out string number);
 280             if (ret != (int)CmError.None)
 281             {
 282                 Log.Error(CmUtility.LogTag, "Failed to get conf call number, Error: " + (CmError)ret);
 283             }
 284
 285             else
 286             {
 287                 confData.Number = number;
 288             }
 289
 290             ret = Interop.CallManager.GetConfCallPersonId(handle, out int personId);
 291             if (ret != (int)CmError.None)
 292             {
 293                 Log.Error(CmUtility.LogTag, "Failed to get conf call person ID, Error: " + (CmError)ret);
 294             }
 295
 296             else
 297             {
 298                 confData.PersonIndex = personId;
 299             }
 300
 301             ret = Interop.CallManager.GetConfCallNameMode(handle, out CallNameMode nameMode);
 302             if (ret != (int)CmError.None)
 303             {
 304                 Log.Error(CmUtility.LogTag, "Failed to get conf call name mode, Error: " + (CmError)ret);
 305             }
 306
 307             else
 308             {
 309                 confData.NameMode = nameMode;
 310             }
 311
 312             return confData;
 313         }
 314
 315         internal static CallEventData GetCallEventData(IntPtr handle)
 316         {
 317             CallEventData eventData = new CallEventData();
 318             int ret = Interop.CallManager.GetEventDataCallId(handle, out uint id);
 319             if (ret != (int)CmError.None)
 320             {
 321                 Log.Error(CmUtility.LogTag, "Failed to get event data call ID, Error: " + (CmError)ret);
 322             }
 323
 324             else
 325             {
 326                 eventData.EventId = id;
 327             }
 328
 329             ret = Interop.CallManager.GetSimSlot(handle, out MultiSimSlot simSlot);
 330             if (ret != (int)CmError.None)
 331             {
 332                 Log.Error(CmUtility.LogTag, "Failed to get event data sim slot, Error: " + (CmError)ret);
 333             }
 334
 335             else
 336             {
 337                 eventData.Slot = simSlot;
 338             }
 339
 340             ret = Interop.CallManager.GetEndCause(handle, out CallEndCause endCause);
 341             if (ret != (int)CmError.None)
 342             {
 343                 Log.Error(CmUtility.LogTag, "Failed to get end cause, Error: " + (CmError)ret);
 344             }
 345
 346             else
 347             {
 348                 eventData.Cause = endCause;
 349             }
 350
 351             ret = Interop.CallManager.GetIncomingCallData(handle, out IntPtr incoming);
 352             if (ret != (int)CmError.None)
 353             {
 354                 Log.Error(CmUtility.LogTag, "Failed to get incoming call data, Error: " + (CmError)ret);
 355             }
 356
 357             else
 358             {
 359                 eventData.Incoming = GetCallData(incoming);
 360             }
 361
 362             ret = Interop.CallManager.GetActiveCall(handle, out IntPtr active);
 363             if (ret != (int)CmError.None)
 364             {
 365                 Log.Error(CmUtility.LogTag, "Failed to get active call data, Error: " + (CmError)ret);
 366             }
 367
 368             else
 369             {
 370                 eventData.Active = GetCallData(active);
 371             }
 372
 373             ret = Interop.CallManager.GetHeldCall(handle, out IntPtr held);
 374             if (ret != (int)CmError.None)
 375             {
 376                 Log.Error(CmUtility.LogTag, "Failed to get held call data, Error: " + (CmError)ret);
 377             }
 378
 379             else
 380             {
 381                 eventData.Held = GetCallData(held);
 382             }
 383
 384             return eventData;
 385         }
 386
 387         internal static void ThrowCmException(int exception)
 388         {
 389             _throwException(exception, false, "");
 390         }
 391
 392         internal static void ThrowCmException(int exception, IntPtr handle)
 393         {
 394             _throwException(exception, (handle == IntPtr.Zero), "");
 395         }
 396
 397         internal static void ThrowCmException(int exception, IntPtr handle, string message)
 398         {
 399             _throwException(exception, (handle == IntPtr.Zero), message);
 400         }
 401
 402         private static void _throwException(int exception, bool isHandleNull, string message)
 403         {
 404             CmError _error = (CmError)exception;
 405             switch(_error)
 406             {
 407                 case CmError.NotSupported:
 408                     throw new NotSupportedException("Unsupported feature: http://tizen.org/feature/network.telephony");
 409                 case CmError.PermissionDenied:
 410                     throw new UnauthorizedAccessException("Permission denied: " + message);
 411                 case CmError.OutOfMemory:
 412                     throw new OutOfMemoryException("System out of memory");
 413                 case CmError.InvalidParameter:
 414                     if (isHandleNull)
 415                     {
 416                         throw new InvalidOperationException("Invalid instance (object may have been disposed or released)");
 417                     }
 418
 419                     throw new ArgumentException("Invalid parameter");
 420                 default:
 421                     throw new InvalidOperationException(_error.ToString());
 422             }
 423         }
 424     }
 425 }