src/Tizen.Telephony/Tizen.Telephony/CallHandle.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 static Interop.Telephony;
  19
  20 namespace Tizen.Telephony
  21 {
  22     /// <summary>
  23     /// This Class provides API's to get the information about calls.
  24     /// </summary>
  25     public class CallHandle
  26     {
  27         private IntPtr _callHandle;
  28
  29         /// <summary>
  30         /// Enumeration for the call status.
  31         /// </summary>
  32         public enum CallStatus
  33         {
  34             /// <summary>
  35             /// Idle status
  36             /// </summary>
  37             Idle,
  38             /// <summary>
  39             /// Active status
  40             /// </summary>
  41             Active,
  42             /// <summary>
  43             /// Held status
  44             /// </summary>
  45             Held,
  46             /// <summary>
  47             /// Dialing status
  48             /// </summary>
  49             Dialing,
  50             /// <summary>
  51             /// Alerting status
  52             /// </summary>
  53             Alerting,
  54             /// <summary>
  55             /// Incoming status
  56             /// </summary>
  57             Incoming,
  58             /// <summary>
  59             /// Unavailable
  60             /// </summary>
  61             Unavailable
  62         };
  63
  64         /// <summary>
  65         /// Enumeration for the call type.
  66         /// </summary>
  67         public enum CallType
  68         {
  69             /// <summary>
  70             /// Voice call
  71             /// </summary>
  72             Voice,
  73             /// <summary>
  74             /// Video call
  75             /// </summary>
  76             Video,
  77             /// <summary>
  78             /// Emergency call
  79             /// </summary>
  80             E911,
  81             /// <summary>
  82             /// Unavailable
  83             /// </summary>
  84             Unavailable
  85         };
  86
  87         /// <summary>
  88         /// Enumeration for the call direction.
  89         /// </summary>
  90         public enum CallDirection
  91         {
  92             /// <summary>
  93             /// MO(Mobile Originated) call
  94             /// </summary>
  95             Mo,
  96             /// <summary>
  97             /// MT(Mobile Terminated) call
  98             /// </summary>
  99             Mt,
 100             /// <summary>
 101             /// Unavailable
 102             /// </summary>
 103             Unavailable
 104         };
 105
 106         /// <summary>
 107         /// Gets the call handle ID.
 108         /// </summary>
 109         /// <since_tizen> 3 </since_tizen>
 110         /// <value>
 111         /// The id of the call handle
 112         /// 0 if unable to complete the operation
 113         /// </value>
 114         public uint HandleId
 115         {
 116             get
 117             {
 118                 uint handleId;
 119                 TelephonyError error = Interop.Call.GetHandleId(_callHandle, out handleId);
 120                 if (error != TelephonyError.None)
 121                 {
 122                     Tizen.Log.Error(Interop.Telephony.LogTag, "GetHandleId Failed with Error " + error);
 123                     return 0;
 124                 }
 125
 126                 return handleId;
 127             }
 128         }
 129
 130         /// <summary>
 131         /// Gets the call number.
 132         /// </summary>
 133         /// <since_tizen> 3 </since_tizen>
 134         /// <value>
 135         /// The number of the call
 136         /// empty string if unable to complete the operation
 137         /// </value>
 138         public string Number
 139         {
 140             get
 141             {
 142                 string number;
 143                 TelephonyError error = Interop.Call.GetNumber(_callHandle, out number);
 144                 if (error != TelephonyError.None)
 145                 {
 146                     Tizen.Log.Error(Interop.Telephony.LogTag, "GetNumber Failed with Error " + error);
 147                     return "";
 148                 }
 149
 150                 return number;
 151             }
 152         }
 153
 154         /// <summary>
 155         /// Gets the call type.
 156         /// </summary>
 157         /// <since_tizen> 3 </since_tizen>
 158         /// <value>
 159         /// The type of the call
 160         /// </value>
 161         public CallType Type
 162         {
 163             get
 164             {
 165                 CallType callType;
 166                 TelephonyError error = Interop.Call.GetType(_callHandle, out callType);
 167                 if (error != TelephonyError.None)
 168                 {
 169                     Tizen.Log.Error(Interop.Telephony.LogTag, "GetType Failed with Error " + error);
 170                     return CallType.Unavailable;
 171                 }
 172
 173                 return callType;
 174             }
 175         }
 176
 177         /// <summary>
 178         /// Gets the call status.
 179         /// </summary>
 180         /// <since_tizen> 3 </since_tizen>
 181         /// <value>
 182         /// The status of the call
 183         /// </value>
 184         public CallStatus Status
 185         {
 186             get
 187             {
 188                 CallStatus callStatus;
 189                 TelephonyError error = Interop.Call.GetStatus(_callHandle, out callStatus);
 190                 if (error != TelephonyError.None)
 191                 {
 192                     Tizen.Log.Error(Interop.Telephony.LogTag, "GetStatus Failed with Error " + error);
 193                     return CallStatus.Unavailable;
 194                 }
 195
 196                 return callStatus;
 197             }
 198         }
 199
 200         /// <summary>
 201         /// Gets whether the call is MO(Mobile Originated) call or MT(Mobile Terminated).
 202         /// </summary>
 203         /// <since_tizen> 3 </since_tizen>
 204         /// <value>
 205         /// The direction of the call
 206         /// </value>
 207         /// <exception cref="InvalidOperationException">
 208         /// This Exception can occur due to:
 209         /// 1. Operation Not Supported
 210         /// </exception>
 211         public CallDirection Direction
 212         {
 213             get
 214             {
 215                 CallDirection callDirection;
 216                 TelephonyError error = Interop.Call.GetDirection(_callHandle, out callDirection);
 217                 if (error != TelephonyError.None)
 218                 {
 219                     Tizen.Log.Error(Interop.Telephony.LogTag, "GetDirection Failed with Error " + error);
 220                     return CallDirection.Unavailable;
 221                 }
 222
 223                 return callDirection;
 224             }
 225
 226         }
 227
 228         /// <summary>
 229         /// Gets whether the call is conference call or not.
 230         /// </summary>
 231         /// <since_tizen> 3 </since_tizen>
 232         /// <value>
 233         /// The value whether the call is conference call or not. (true: Conference call, false: Single call)
 234         /// </value>
 235         public bool ConferenceStatus
 236         {
 237             get
 238             {
 239                 bool callConfStatus;
 240                 TelephonyError error = Interop.Call.GetConferenceStatus(_callHandle, out callConfStatus);
 241                 if (error != TelephonyError.None)
 242                 {
 243                     Tizen.Log.Error(Interop.Telephony.LogTag, "GetConferenceStatus Failed with Error " + error);
 244                     return false;
 245                 }
 246
 247                 return callConfStatus;
 248             }
 249
 250         }
 251
 252         internal CallHandle(IntPtr handle)
 253         {
 254             _callHandle = handle;
 255         }
 256     }
 257 }