src/Tizen.Tapi/Tizen.Tapi/NetworkStructs.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.Runtime.InteropServices;
  20
  21 namespace Tizen.Tapi
  22 {
  23     [StructLayout(LayoutKind.Sequential)]
  24     internal struct NetworkRegistrationStatusStruct
  25     {
  26         internal NetworkServiceLevel Cs;
  27         internal NetworkServiceLevel Ps;
  28         internal NetworkServiceType Type;
  29         internal int IsRoaming;
  30     }
  31
  32     [StructLayout(LayoutKind.Sequential)]
  33     internal struct NetworkCellNotiStruct
  34     {
  35         internal int Lac;
  36         internal int CellId;
  37     }
  38
  39     [StructLayout(LayoutKind.Sequential)]
  40     internal struct NetworkChangeNotiStruct
  41     {
  42         internal NetworkSystemType Act;
  43         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)]
  44         internal string Plmn;
  45     }
  46
  47     [StructLayout(LayoutKind.Sequential)]
  48     internal struct NetworkTimeNotiStruct
  49     {
  50         internal int Year;
  51         internal int Month;
  52         internal int Day;
  53         internal int Hour;
  54         internal int Minute;
  55         internal int Second;
  56         internal int WDay;
  57         internal int GmtOff;
  58         internal int DstOff;
  59         internal int IsDst;
  60         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)]
  61         internal string Plmn;
  62     }
  63
  64     [StructLayout(LayoutKind.Sequential)]
  65     internal struct NetworkIdentityNotiStruct
  66     {
  67         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)]
  68         internal string Plmn;
  69         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 17)]
  70         internal string ShortName;
  71         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 33)]
  72         internal string FullName;
  73     }
  74
  75     [StructLayout(LayoutKind.Sequential)]
  76     internal struct NetworkVolteStatusStruct
  77     {
  78         internal int IsRegistered;
  79         internal int FeatureMask;
  80         internal VolteNetworkType NetworkType;
  81     }
  82
  83     [StructLayout(LayoutKind.Sequential)]
  84     internal struct NetworkPreferredPlmnStruct
  85     {
  86         internal byte Index;
  87         [MarshalAs(UnmanagedType.ByValTStr, SizeConst=7)]
  88         internal string Plmn;
  89         [MarshalAs(UnmanagedType.ByValTStr, SizeConst=41)]
  90         internal string NetworkName;
  91         [MarshalAs(UnmanagedType.ByValTStr, SizeConst=41)]
  92         internal string SnName;
  93         internal NetworkSystemType Type;
  94     }
  95
  96     [StructLayout(LayoutKind.Sequential)]
  97     internal struct NetworkIdentityStruct
  98     {
  99         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 41)]
 100         internal string NwName;
 101         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 41)]
 102         internal string SvcName;
 103         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)]
 104         internal string NwPlmn;
 105         internal uint PlmnId;
 106         internal NetworkPlmnType Type;
 107         internal NetworkSystemType Act;
 108     }
 109
 110     [StructLayout(LayoutKind.Sequential)]
 111     internal struct NetworkPlmnListStruct
 112     {
 113         internal byte NwCount;
 114         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20, ArraySubType = UnmanagedType.LPStruct)]
 115         internal NetworkIdentityStruct[] NwList;
 116     }
 117
 118     [StructLayout(LayoutKind.Sequential)]
 119     internal struct NetworkPreferredPlmnListStruct
 120     {
 121         internal uint Count;
 122         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 150, ArraySubType = UnmanagedType.LPStruct)]
 123         internal NetworkPreferredPlmnStruct[] PlmnList;
 124     }
 125
 126     [StructLayout(LayoutKind.Sequential)]
 127     internal struct NetworkCdmaSysStruct
 128     {
 129         internal int Carrier;
 130         internal uint SysId;
 131         internal uint NwId;
 132         internal uint BaseStnId;
 133         internal int BaseStnLatitude;
 134         internal int BaseStnLongitude;
 135         internal uint RegZone;
 136         internal uint Offset;
 137     }
 138
 139     [StructLayout(LayoutKind.Explicit)]
 140     internal struct NetworkAreaStruct
 141     {
 142         [FieldOffset(0)]
 143         internal int Lac;
 144         [FieldOffset(0)]
 145         internal NetworkCdmaSysStruct Cdma;
 146     }
 147
 148     [StructLayout(LayoutKind.Sequential)]
 149     internal struct NetworkServingStruct
 150     {
 151         internal NetworkSystemType SysType;
 152         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)]
 153         internal string Plmn;
 154         internal NetworkAreaStruct Area;
 155     }
 156
 157     [StructLayout(LayoutKind.Sequential)]
 158     internal struct NetworkGeranCellStruct
 159     {
 160         internal int CellId;
 161         internal int Lac;
 162         internal int Bcch;
 163         internal int Bsic;
 164         internal int Rxlev;
 165     }
 166
 167     [StructLayout(LayoutKind.Sequential)]
 168     internal struct NetworkUmtsCellStruct
 169     {
 170         internal int CellId;
 171         internal int Lac;
 172         internal int Arfcn;
 173         internal int Psc;
 174         internal int Rscp;
 175     }
 176
 177     [StructLayout(LayoutKind.Sequential)]
 178     internal struct NetworkLteCellStruct
 179     {
 180         internal int CellId;
 181         internal int Lac;
 182         internal int Pcid;
 183         internal int Earfcn;
 184         internal int Tac;
 185         internal int Rssi;
 186     }
 187
 188     [StructLayout(LayoutKind.Sequential)]
 189     internal struct NetworkCdmaCellStruct
 190     {
 191         internal uint SystemId;
 192         internal uint NetworkId;
 193         internal uint BaseId;
 194         internal uint RefPn;
 195         internal int BaseStnLatitude;
 196         internal int BaseStnLongitude;
 197     }
 198
 199     [StructLayout(LayoutKind.Explicit)]
 200     internal struct CellStruct
 201     {
 202         [FieldOffset(0)]
 203         internal NetworkGeranCellStruct Geran;
 204         [FieldOffset(0)]
 205         internal NetworkUmtsCellStruct Umts;
 206         [FieldOffset(0)]
 207         internal NetworkLteCellStruct Lte;
 208         [FieldOffset(0)]
 209         internal NetworkCdmaCellStruct Cdma;
 210     }
 211
 212     [StructLayout(LayoutKind.Sequential)]
 213     internal struct NetworkServingCellStruct
 214     {
 215         internal NetworkSystemType SystemType;
 216         internal int MobileCountryCode;
 217         internal int MobileNetworkCode;
 218         internal CellStruct Cell;
 219     }
 220
 221     [StructLayout(LayoutKind.Sequential)]
 222     internal struct NetworkNeighboringCellStruct
 223     {
 224         internal NetworkServingCellStruct ServCell;
 225         internal int GeranCount;
 226         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6, ArraySubType = UnmanagedType.LPStruct)]
 227         internal NetworkGeranCellStruct[] GeranList;
 228         internal int UmtsCount;
 229         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24, ArraySubType = UnmanagedType.LPStruct)]
 230         internal NetworkUmtsCellStruct[] UmtsList;
 231         internal int LteCount;
 232         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24, ArraySubType = UnmanagedType.LPStruct)]
 233         internal NetworkLteCellStruct[] LteList;
 234     }
 235
 236     internal static class NetworkStructConversions
 237     {
 238         internal static NetworkRegistrationStatus ConvertNetworkRegistrationStruct(NetworkRegistrationStatusStruct statusStruct)
 239         {
 240             NetworkRegistrationStatus status = new NetworkRegistrationStatus();
 241             status.Cs = statusStruct.Cs;
 242             status.Ps = statusStruct.Ps;
 243             status.SvcType = statusStruct.Type;
 244             if (statusStruct.IsRoaming == 1)
 245             {
 246                 status.Roaming = true;
 247             }
 248
 249             else if (statusStruct.IsRoaming == 0)
 250             {
 251                 status.Roaming = false;
 252             }
 253
 254             return status;
 255         }
 256
 257         internal static NetworkCellNoti ConvertNetworkCellNotiStruct(NetworkCellNotiStruct notiStruct)
 258         {
 259             NetworkCellNoti noti = new NetworkCellNoti();
 260             noti.Location = notiStruct.Lac;
 261             noti.Id = notiStruct.CellId;
 262             return noti;
 263         }
 264
 265         internal static NetworkChangeNoti ConvertNetworkChangeStruct(NetworkChangeNotiStruct changeStruct)
 266         {
 267             NetworkChangeNoti changeNoti = new NetworkChangeNoti();
 268             changeNoti.Type = changeStruct.Act;
 269             changeNoti.NwPlmn = changeStruct.Plmn;
 270             return changeNoti;
 271         }
 272
 273         internal static NetworkTimeNoti ConvertNetworkTimeNotiStruct(NetworkTimeNotiStruct notiStruct)
 274         {
 275             NetworkTimeNoti time = new NetworkTimeNoti();
 276             time.TimeInfo = new DateTime(notiStruct.Year, notiStruct.Month, notiStruct.Day, notiStruct.Hour, notiStruct.Minute, notiStruct.Second);
 277             time.WDayInfo = notiStruct.WDay;
 278             time.GmtOffInfo = notiStruct.GmtOff;
 279             time.DstOffInfo = notiStruct.DstOff;
 280             if (notiStruct.IsDst == 1)
 281             {
 282                 time.Dst = true;
 283             }
 284
 285             else if (notiStruct.IsDst == 0)
 286             {
 287                 time.Dst = false;
 288             }
 289
 290             time.NetworkPlmn = notiStruct.Plmn;
 291             return time;
 292         }
 293
 294         internal static NetworkIdentityNoti ConvertNetworkIdentityStruct(NetworkIdentityNotiStruct notiStruct)
 295         {
 296             NetworkIdentityNoti identity = new NetworkIdentityNoti();
 297             identity.NwPlmn = notiStruct.Plmn;
 298             identity.NwShortName = notiStruct.ShortName;
 299             identity.NwFullName = notiStruct.FullName;
 300             return identity;
 301         }
 302
 303         internal static NetworkVolteStatus ConvertNetworkVolteStruct(NetworkVolteStatusStruct notiStruct)
 304         {
 305             NetworkVolteStatus volteStatus = new NetworkVolteStatus();
 306             if (notiStruct.IsRegistered == 1)
 307             {
 308                 volteStatus.NwIsRegistered = true;
 309             }
 310
 311             else if (notiStruct.IsRegistered == 0)
 312             {
 313                 volteStatus.NwIsRegistered = false;
 314             }
 315
 316             volteStatus.NwFeatureMask = notiStruct.FeatureMask;
 317             volteStatus.NwType = notiStruct.NetworkType;
 318             return volteStatus;
 319         }
 320
 321         internal static NetworkPlmnList ConvertNetworkPlmnListStruct(NetworkPlmnListStruct listStruct)
 322         {
 323             NetworkPlmnList plmnList = new NetworkPlmnList();
 324             List<NetworkIdentity> records = new List<NetworkIdentity>();
 325
 326             foreach (NetworkIdentityStruct idStruct in listStruct.NwList)
 327             {
 328                 NetworkIdentity identity = new NetworkIdentity();
 329                 identity.Id = idStruct.PlmnId;
 330                 identity.SvcProviderName = idStruct.SvcName;
 331                 identity.IdName = idStruct.NwName;
 332                 identity.PlmnName = idStruct.NwPlmn;
 333                 identity.PlmnNwType = idStruct.Type;
 334                 identity.SysType = idStruct.Act;
 335                 records.Add(identity);
 336             }
 337
 338             plmnList.NwCount = listStruct.NwCount;
 339             plmnList.NwList = records;
 340             return plmnList;
 341         }
 342
 343         internal static IEnumerable<NetworkPreferredPlmnInfo> ConvertNetworkPreferredPlmnStruct(NetworkPreferredPlmnListStruct plmnStruct)
 344         {
 345             List<NetworkPreferredPlmnInfo> plmnList = new List<NetworkPreferredPlmnInfo>();
 346
 347             for (int i = 0; i <= plmnStruct.Count; i++)
 348             {
 349                 NetworkPreferredPlmnInfo plmnInfo = new NetworkPreferredPlmnInfo();
 350                 plmnInfo.idex = plmnStruct.PlmnList[i].Index;
 351                 plmnInfo.NwName = plmnStruct.PlmnList[i].NetworkName;
 352                 plmnInfo.NwPlmn = plmnStruct.PlmnList[i].Plmn;
 353                 plmnInfo.SvcProvName = plmnStruct.PlmnList[i].SnName;
 354                 plmnInfo.SysType = plmnStruct.PlmnList[i].Type;
 355                 plmnList.Add(plmnInfo);
 356             }
 357
 358             return plmnList;
 359         }
 360
 361         internal static NetworkCdmaSysInfo ConvertCdmaStruct(NetworkCdmaSysStruct cdmaStruct)
 362         {
 363             NetworkCdmaSysInfo cdmaInfo = new NetworkCdmaSysInfo();
 364             cdmaInfo.Car = cdmaStruct.Carrier;
 365             cdmaInfo.BaseStnId = cdmaStruct.BaseStnId;
 366             cdmaInfo.BaseStnLatitude = cdmaStruct.BaseStnLatitude;
 367             cdmaInfo.BaseStnLongitude = cdmaStruct.BaseStnLongitude;
 368             cdmaInfo.NwId = cdmaStruct.NwId;
 369             cdmaInfo.Offset = cdmaStruct.Offset;
 370             cdmaInfo.RegZone = cdmaStruct.RegZone;
 371             cdmaInfo.SysId = cdmaStruct.SysId;
 372             return cdmaInfo;
 373         }
 374
 375         internal static NetworkServing ConvertNetworkServingStruct(NetworkServingStruct servStruct)
 376         {
 377             NetworkServing servingInfo = new NetworkServing();
 378             NetworkAreaStruct areaStruct = servStruct.Area;
 379             NetworkCdmaSysStruct cdmaStruct = areaStruct.Cdma;
 380             NetworkCdmaSysInfo cdmaInfo = ConvertCdmaStruct(cdmaStruct);
 381
 382             NetworkAreaInfo areaInfo = new NetworkAreaInfo();
 383             areaInfo.Code = areaStruct.Lac;
 384             areaInfo.Cdma = cdmaInfo;
 385
 386             servingInfo.NwPlmn = servStruct.Plmn;
 387             servingInfo.Type = servStruct.SysType;
 388             servingInfo.Area = areaInfo;
 389
 390             return servingInfo;
 391         }
 392
 393         internal static NetworkGeranCell ConvertGeranStruct(NetworkGeranCellStruct geranStruct)
 394         {
 395             NetworkGeranCell geranCell = new NetworkGeranCell();
 396             geranCell.Bc = geranStruct.Bcch;
 397             geranCell.Bs = geranStruct.Bsic;
 398             geranCell.Id = geranStruct.CellId;
 399             geranCell.Lc = geranStruct.Lac;
 400             geranCell.Rx = geranStruct.Rxlev;
 401             return geranCell;
 402         }
 403
 404         internal static NetworkUmtsCell ConvertUmtsStruct(NetworkUmtsCellStruct umtsStruct)
 405         {
 406             NetworkUmtsCell umtsCell = new NetworkUmtsCell();
 407             umtsCell.Arf = umtsStruct.Arfcn;
 408             umtsCell.Id = umtsStruct.CellId;
 409             umtsCell.Lc = umtsStruct.Lac;
 410             umtsCell.Ps = umtsStruct.Psc;
 411             umtsCell.Rsc = umtsStruct.Rscp;
 412             return umtsCell;
 413         }
 414
 415         internal static NetworkLteCell ConvertLteStruct(NetworkLteCellStruct lteStruct)
 416         {
 417             NetworkLteCell lteCell = new NetworkLteCell();
 418             lteCell.Id = lteStruct.CellId;
 419             lteCell.Erf = lteStruct.Earfcn;
 420             lteCell.Lc = lteStruct.Lac;
 421             lteCell.PId = lteStruct.Pcid;
 422             lteCell.Tc = lteStruct.Tac;
 423             lteCell.Rs = lteStruct.Rssi;
 424             return lteCell;
 425         }
 426
 427         internal static NetworkNeighboringCell ConvertNeighborCellStruct(NetworkNeighboringCellStruct neighborStruct)
 428         {
 429             NetworkNeighboringCell neighborCell = new NetworkNeighboringCell();
 430             NetworkServingCellStruct servStruct = neighborStruct.ServCell;
 431             CellStruct cellStruct = servStruct.Cell;
 432             NetworkGeranCellStruct geranStruct = cellStruct.Geran;
 433             NetworkCdmaCellStruct cdmaStruct = cellStruct.Cdma;
 434             NetworkUmtsCellStruct umtsStruct = cellStruct.Umts;
 435             NetworkLteCellStruct lteStruct = cellStruct.Lte;
 436
 437             NetworkGeranCell geranCell = ConvertGeranStruct(geranStruct);
 438
 439             NetworkCdmaCell cdmaCell = new NetworkCdmaCell();
 440             cdmaCell.BaseStnId = cdmaStruct.BaseId;
 441             cdmaCell.BaseStnLatitude = cdmaStruct.BaseStnLatitude;
 442             cdmaCell.BaseStnLongitude = cdmaStruct.BaseStnLongitude;
 443             cdmaCell.NwId = cdmaStruct.NetworkId;
 444             cdmaCell.RefPn = cdmaStruct.RefPn;
 445             cdmaCell.SysId = cdmaStruct.SystemId;
 446
 447             NetworkUmtsCell umtsCell = ConvertUmtsStruct(umtsStruct);
 448
 449             NetworkLteCell lteCell = ConvertLteStruct(lteStruct);
 450
 451             Cell cell = new Cell();
 452             cell.Geran = geranCell;
 453             cell.Cdma = cdmaCell;
 454             cell.Umts = umtsCell;
 455             cell.Lte = lteCell;
 456
 457             NetworkServingCell servingCell = new NetworkServingCell();
 458             servingCell.SysType = servStruct.SystemType;
 459             servingCell.MCountryCode = servStruct.MobileCountryCode;
 460             servingCell.MNwCode = servStruct.MobileNetworkCode;
 461             servingCell.Info = cell;
 462
 463             neighborCell.ServCell = servingCell;
 464             List<NetworkGeranCell> geranCellList = new List<NetworkGeranCell>();
 465             for(int i=0;i<neighborStruct.GeranCount;i++)
 466             {
 467                 NetworkGeranCell geran = ConvertGeranStruct(neighborStruct.GeranList[i]);
 468                 geranCellList.Add(geran);
 469             }
 470
 471             List<NetworkUmtsCell> umtsCellList = new List<NetworkUmtsCell>();
 472             for (int i = 0; i < neighborStruct.UmtsCount; i++)
 473             {
 474                 NetworkUmtsCell umts = ConvertUmtsStruct(neighborStruct.UmtsList[i]);
 475                 umtsCellList.Add(umts);
 476             }
 477
 478             List<NetworkLteCell> lteCellList = new List<NetworkLteCell>();
 479             for (int i = 0; i < neighborStruct.GeranCount; i++)
 480             {
 481                 NetworkLteCell lte = ConvertLteStruct(neighborStruct.LteList[i]);
 482                 lteCellList.Add(lte);
 483             }
 484
 485             neighborCell.GrList = geranCellList;
 486             neighborCell.UmtList = umtsCellList;
 487             neighborCell.LtList = lteCellList;
 488             return neighborCell;
 489
 490         }
 491     }
 492
 493     internal static class NetworkClassConversions
 494     {
 495         internal static NetworkPreferredPlmnStruct ConvertNetworkPreferredPlmn(NetworkPreferredPlmnInfo plmnInfo)
 496         {
 497             NetworkPreferredPlmnStruct plmnStruct = new NetworkPreferredPlmnStruct();
 498             plmnStruct.Index = plmnInfo.idex;
 499             plmnStruct.NetworkName = plmnInfo.NwName;
 500             plmnStruct.Plmn = plmnInfo.NwPlmn;
 501             plmnStruct.SnName = plmnInfo.SvcProvName;
 502             plmnStruct.Type = plmnInfo.SysType;
 503             return plmnStruct;
 504         }
 505     }
 506 }