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