WifiPasspointDmTree.java revision 08c7116ab9cd04ad6dd3c04aa1017237e7f409ac
1/* 2 * Copyright (C) 2014 The Android Open Source Project 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 17package android.net.wifi.passpoint; 18 19import android.os.Parcelable; 20import android.os.Parcel; 21import java.util.HashMap; 22 23/** 24 * Required Mobile Device Management Tree Structure 25 * 26 * +----------+ 27 * | ./(Root) | 28 * +----+-----+ 29 * | 30 * +---------+ | +---------+ +---------+ 31 * | DevInfo |-----------+---------| Wi-Fi |--|SP FQDN* | 32 * +---------+ | +---------+ +---------+ 33 * +---------+ | | 34 * |DevDetail|-----------+ +-----------------------+ 35 * +---------+ |PerproviderSubscription|--<X>+ 36 * +-----------------------+ 37 * 38 * This class contains all nodes start from Wi-Fi 39 * @hide 40 **/ 41public class WifiPasspointDmTree implements Parcelable { 42 private final static String TAG = "WifiTree"; 43 public int PpsMoId;//plugfest used only 44 public HashMap<String, SpFqdn> spFqdn = new HashMap<String, SpFqdn>();//Maps.newHashMap(); 45 46 public SpFqdn createSpFqdn(String name) { 47 SpFqdn obj = new SpFqdn(name); 48 spFqdn.put(name, obj); 49 return obj; 50 } 51 52 public static class SpFqdn implements Parcelable { 53 public String nodeName; 54 public PerProviderSubscription perProviderSubscription = new PerProviderSubscription(); 55 56 public SpFqdn(String name) { 57 nodeName = name; 58 } 59 60 public SpFqdn() { 61 } 62 63 public SpFqdn(Parcel in) { 64 readFromParcel(in); 65 } 66 67 public int describeContents() { 68 return 0; 69 } 70 71 public void writeToParcel(Parcel out, int flags) { 72 out.writeString(nodeName); 73 out.writeParcelable(perProviderSubscription, flags); 74 } 75 76 public void readFromParcel(Parcel in) { 77 if (in == null) { 78 //log here 79 } else { 80 nodeName = in.readString(); 81 perProviderSubscription = in.readParcelable(PerProviderSubscription.class 82 .getClassLoader()); 83 } 84 } 85 86 public static final Parcelable.Creator<SpFqdn> CREATOR = new Parcelable.Creator<SpFqdn>() { 87 public SpFqdn createFromParcel(Parcel in) { 88 return new SpFqdn(in); 89 } 90 91 public SpFqdn[] newArray(int size) { 92 return new SpFqdn[size]; 93 } 94 }; 95 } 96 97 /** 98 * PerProviderSubscription 99 **/ 100 public static class PerProviderSubscription implements Parcelable { 101 /** 102 * PerProviderSubscription/UpdateIdentifier 103 **/ 104 public String UpdateIdentifier; 105 public HashMap<String, CredentialInfo> credentialInfo = new HashMap<String, CredentialInfo>(); 106 107 public CredentialInfo createCredentialInfo(String name) { 108 CredentialInfo obj = new CredentialInfo(name); 109 credentialInfo.put(name, obj); 110 return obj; 111 } 112 113 public PerProviderSubscription() { 114 } 115 116 public PerProviderSubscription(Parcel in) { 117 readFromParcel(in); 118 } 119 120 public int describeContents() { 121 return 0; 122 } 123 124 public void writeToParcel(Parcel out, int flags) { 125 out.writeString(UpdateIdentifier); 126 out.writeMap(credentialInfo); 127 } 128 129 public void readFromParcel(Parcel in) { 130 if (in == null) { 131 //log here 132 } else { 133 UpdateIdentifier = in.readString(); 134 in.readMap(credentialInfo, CredentialInfo.class.getClassLoader()); 135 } 136 } 137 138 public static final Parcelable.Creator<PerProviderSubscription> CREATOR = new Parcelable.Creator<PerProviderSubscription>() { 139 public PerProviderSubscription createFromParcel(Parcel in) { 140 return new PerProviderSubscription(in); 141 } 142 143 public PerProviderSubscription[] newArray(int size) { 144 return new PerProviderSubscription[size]; 145 } 146 }; 147 148 } 149 150 /** 151 * PerProviderSubscription/<X+> 152 * This interior node contains the Home SP information, subscription policy, management and credential information. 153 **/ 154 public static class CredentialInfo implements Parcelable { 155 public String nodeName; 156 public Policy policy = new Policy(); 157 public String credentialPriority; 158 public HashMap<String, AAAServerTrustRoot> aAAServerTrustRoot = new HashMap<String, AAAServerTrustRoot>(); 159 public SubscriptionUpdate subscriptionUpdate = new SubscriptionUpdate(); 160 public HomeSP homeSP = new HomeSP(); 161 public SubscriptionParameters subscriptionParameters = new SubscriptionParameters(); 162 public Credential credential = new Credential(); 163 public Extension extension = new Extension(); 164 165 public CredentialInfo(String nn) { 166 nodeName = nn; 167 } 168 169 public AAAServerTrustRoot createAAAServerTrustRoot(String name, String url, String fp) { 170 AAAServerTrustRoot obj = new AAAServerTrustRoot(name, url, fp); 171 aAAServerTrustRoot.put(name, obj); 172 return obj; 173 } 174 175 public CredentialInfo() { 176 } 177 178 public CredentialInfo(Parcel in) { 179 readFromParcel(in); 180 } 181 182 public int describeContents() { 183 return 0; 184 } 185 186 public void writeToParcel(Parcel out, int flags) { 187 out.writeString(nodeName); 188 out.writeParcelable(policy, flags); 189 out.writeString(credentialPriority); 190 out.writeMap(aAAServerTrustRoot); 191 out.writeParcelable(subscriptionUpdate, flags); 192 out.writeParcelable(homeSP, flags); 193 out.writeParcelable(subscriptionParameters, flags); 194 out.writeParcelable(credential, flags); 195 //out.writeParcelable(extension, flags); 196 } 197 198 public void readFromParcel(Parcel in) { 199 if (in == null) { 200 //log here 201 } else { 202 nodeName = in.readString(); 203 policy = in.readParcelable(Policy.class.getClassLoader()); 204 credentialPriority = in.readString(); 205 in.readMap(aAAServerTrustRoot, AAAServerTrustRoot.class.getClassLoader()); 206 subscriptionUpdate = in.readParcelable(SubscriptionUpdate.class.getClassLoader()); 207 homeSP = in.readParcelable(HomeSP.class.getClassLoader()); 208 subscriptionParameters = in.readParcelable(SubscriptionParameters.class 209 .getClassLoader()); 210 credential = in.readParcelable(Credential.class.getClassLoader()); 211 //extension = in.readParcelable(Extension.class.getClassLoader()); 212 } 213 } 214 215 public static final Parcelable.Creator<CredentialInfo> CREATOR = new Parcelable.Creator<CredentialInfo>() { 216 public CredentialInfo createFromParcel(Parcel in) { 217 return new CredentialInfo(in); 218 } 219 220 public CredentialInfo[] newArray(int size) { 221 return new CredentialInfo[size]; 222 } 223 }; 224 225 } 226 227 /** 228 * PerProviderSubscription/<X+>/Policy 229 **/ 230 public static class Policy implements Parcelable { 231 public HashMap<String, PreferredRoamingPartnerList> preferredRoamingPartnerList = new HashMap<String, PreferredRoamingPartnerList>(); 232 public HashMap<String, MinBackhaulThresholdNetwork> minBackhaulThreshold = new HashMap<String, MinBackhaulThresholdNetwork>(); 233 public PolicyUpdate policyUpdate = new PolicyUpdate(); 234 public HashMap<String, SPExclusionList> sPExclusionList = new HashMap<String, SPExclusionList>(); 235 public HashMap<String, RequiredProtoPortTuple> requiredProtoPortTuple = new HashMap<String, RequiredProtoPortTuple>(); 236 public String maximumBSSLoadValue; 237 238 public PreferredRoamingPartnerList createPreferredRoamingPartnerList(String name, 239 String fqdn, String priority, String country) { 240 PreferredRoamingPartnerList obj = new PreferredRoamingPartnerList(name, fqdn, priority, 241 country); 242 preferredRoamingPartnerList.put(name, obj); 243 return obj; 244 } 245 246 public MinBackhaulThresholdNetwork createMinBackhaulThreshold(String name, String type, 247 String dl, String ul) { 248 MinBackhaulThresholdNetwork obj = new MinBackhaulThresholdNetwork(name, type, dl, ul); 249 minBackhaulThreshold.put(name, obj); 250 return obj; 251 } 252 253 public SPExclusionList createSPExclusionList(String name, String ssid) { 254 SPExclusionList obj = new SPExclusionList(name, ssid); 255 sPExclusionList.put(name, obj); 256 return obj; 257 } 258 259 public RequiredProtoPortTuple createRequiredProtoPortTuple(String name, String proto, 260 String port) { 261 RequiredProtoPortTuple obj = new RequiredProtoPortTuple(name, proto, port); 262 requiredProtoPortTuple.put(name, obj); 263 return obj; 264 } 265 266 public Policy() { 267 } 268 269 public Policy(Parcel in) { 270 readFromParcel(in); 271 } 272 273 public int describeContents() { 274 return 0; 275 } 276 277 public void writeToParcel(Parcel out, int flags) { 278 out.writeMap(preferredRoamingPartnerList); 279 out.writeMap(minBackhaulThreshold); 280 out.writeParcelable(policyUpdate, flags); 281 out.writeMap(sPExclusionList); 282 out.writeMap(requiredProtoPortTuple); 283 out.writeString(maximumBSSLoadValue); 284 } 285 286 public void readFromParcel(Parcel in) { 287 if (in == null) { 288 //log here 289 } else { 290 in.readMap(preferredRoamingPartnerList, 291 PreferredRoamingPartnerList.class.getClassLoader()); 292 in.readMap(minBackhaulThreshold, MinBackhaulThresholdNetwork.class.getClassLoader()); 293 policyUpdate = in.readParcelable(PolicyUpdate.class.getClassLoader()); 294 in.readMap(sPExclusionList, SPExclusionList.class.getClassLoader()); 295 in.readMap(requiredProtoPortTuple, RequiredProtoPortTuple.class.getClassLoader()); 296 maximumBSSLoadValue = in.readString(); 297 298 } 299 } 300 301 public static final Parcelable.Creator<Policy> CREATOR = new Parcelable.Creator<Policy>() { 302 public Policy createFromParcel(Parcel in) { 303 return new Policy(in); 304 } 305 306 public Policy[] newArray(int size) { 307 return new Policy[size]; 308 } 309 }; 310 311 } 312 313 /** 314 * PerProviderSubscription/<X+>/Policy/PreferredRoamingPartnerList/<X+> 315 **/ 316 public static class PreferredRoamingPartnerList implements Parcelable { 317 public String nodeName; 318 public String FQDN_Match; //maximum 255 + ",includeSubdomains", equals 273 319 public String Priority; 320 public String Country; // maximum 600 octets 321 322 public PreferredRoamingPartnerList(String nn, String f, String p, String c) { 323 nodeName = nn; 324 FQDN_Match = f; 325 Priority = p; 326 Country = c; 327 } 328 329 public PreferredRoamingPartnerList() { 330 } 331 332 public PreferredRoamingPartnerList(Parcel in) { 333 readFromParcel(in); 334 } 335 336 public int describeContents() { 337 return 0; 338 } 339 340 public void writeToParcel(Parcel out, int flags) { 341 out.writeString(nodeName); 342 out.writeString(FQDN_Match); 343 out.writeString(Priority); 344 out.writeString(Country); 345 } 346 347 public void readFromParcel(Parcel in) { 348 if (in == null) { 349 //log here 350 } else { 351 nodeName = in.readString(); 352 FQDN_Match = in.readString(); 353 Priority = in.readString(); 354 Country = in.readString(); 355 } 356 } 357 358 public static final Parcelable.Creator<PreferredRoamingPartnerList> CREATOR = new Parcelable.Creator<PreferredRoamingPartnerList>() { 359 public PreferredRoamingPartnerList createFromParcel(Parcel in) { 360 return new PreferredRoamingPartnerList(in); 361 } 362 363 public PreferredRoamingPartnerList[] newArray(int size) { 364 return new PreferredRoamingPartnerList[size]; 365 } 366 }; 367 } 368 369 /** 370 * PerProviderSubscription/<X+>/Policy/MinBackhaulThreshold 371 **/ 372 public static class MinBackhaulThresholdNetwork implements Parcelable { 373 public String nodeName; 374 public String NetworkType; 375 public String DLBandwidth; 376 public String ULBandwidth; 377 378 public MinBackhaulThresholdNetwork(String nn, String nt, String d, String u) { 379 nodeName = nn; 380 NetworkType = nt; 381 DLBandwidth = d; 382 ULBandwidth = u; 383 } 384 385 public MinBackhaulThresholdNetwork() { 386 } 387 388 public MinBackhaulThresholdNetwork(Parcel in) { 389 readFromParcel(in); 390 } 391 392 public int describeContents() { 393 return 0; 394 } 395 396 public void writeToParcel(Parcel out, int flags) { 397 out.writeString(nodeName); 398 out.writeString(NetworkType); 399 out.writeString(DLBandwidth); 400 out.writeString(ULBandwidth); 401 } 402 403 public void readFromParcel(Parcel in) { 404 if (in == null) { 405 //log here 406 } else { 407 nodeName = in.readString(); 408 NetworkType = in.readString(); 409 DLBandwidth = in.readString(); 410 ULBandwidth = in.readString(); 411 } 412 } 413 414 public static final Parcelable.Creator<MinBackhaulThresholdNetwork> CREATOR = new Parcelable.Creator<MinBackhaulThresholdNetwork>() { 415 public MinBackhaulThresholdNetwork createFromParcel(Parcel in) { 416 return new MinBackhaulThresholdNetwork(in); 417 } 418 419 public MinBackhaulThresholdNetwork[] newArray(int size) { 420 return new MinBackhaulThresholdNetwork[size]; 421 } 422 }; 423 424 } 425 426 /** 427 * PerProviderSubscription/<X+>/Policy/PolicyUpdate 428 **/ 429 public static class PolicyUpdate implements Parcelable { 430 public String UpdateInterval; 431 public String UpdateMethod; 432 public String Restriction; 433 public String URI; 434 public UsernamePassword usernamePassword = new UsernamePassword(); 435 public String Other; 436 public TrustRoot trustRoot = new TrustRoot(); 437 438 public PolicyUpdate() { 439 } 440 441 public PolicyUpdate(Parcel in) { 442 readFromParcel(in); 443 } 444 445 public int describeContents() { 446 return 0; 447 } 448 449 public void writeToParcel(Parcel out, int flags) { 450 out.writeString(UpdateInterval); 451 out.writeString(UpdateMethod); 452 out.writeString(Restriction); 453 out.writeString(URI); 454 out.writeParcelable(usernamePassword, flags); 455 out.writeString(Other); 456 out.writeParcelable(trustRoot, flags); 457 458 } 459 460 public void readFromParcel(Parcel in) { 461 if (in == null) { 462 //log here 463 } else { 464 UpdateInterval = in.readString(); 465 UpdateMethod = in.readString(); 466 Restriction = in.readString(); 467 URI = in.readString(); 468 usernamePassword = in.readParcelable(UsernamePassword.class.getClassLoader()); 469 Other = in.readString(); 470 trustRoot = in.readParcelable(TrustRoot.class.getClassLoader()); 471 } 472 } 473 474 public static final Parcelable.Creator<PolicyUpdate> CREATOR = new Parcelable.Creator<PolicyUpdate>() { 475 public PolicyUpdate createFromParcel(Parcel in) { 476 return new PolicyUpdate(in); 477 } 478 479 public PolicyUpdate[] newArray(int size) { 480 return new PolicyUpdate[size]; 481 } 482 }; 483 } 484 485 /** 486 * PerProviderSubscription/<X+>/Policy/SPExclusionList 487 **/ 488 public static class SPExclusionList implements Parcelable { 489 public String nodeName; 490 public String SSID; 491 492 public SPExclusionList(String nn, String s) { 493 nodeName = nn; 494 SSID = s; 495 } 496 497 public SPExclusionList() { 498 } 499 500 public SPExclusionList(Parcel in) { 501 readFromParcel(in); 502 } 503 504 public int describeContents() { 505 return 0; 506 } 507 508 public void writeToParcel(Parcel out, int flags) { 509 out.writeString(nodeName); 510 out.writeString(SSID); 511 } 512 513 public void readFromParcel(Parcel in) { 514 if (in == null) { 515 //log here 516 } else { 517 nodeName = in.readString(); 518 SSID = in.readString(); 519 } 520 } 521 522 public static final Parcelable.Creator<SPExclusionList> CREATOR = new Parcelable.Creator<SPExclusionList>() { 523 public SPExclusionList createFromParcel(Parcel in) { 524 return new SPExclusionList(in); 525 } 526 527 public SPExclusionList[] newArray(int size) { 528 return new SPExclusionList[size]; 529 } 530 }; 531 } 532 533 /** 534 * PerProviderSubscription/<X+>/Policy/RequiredProtoPortTuple 535 **/ 536 public static class RequiredProtoPortTuple implements Parcelable { 537 public String nodeName; 538 public String IPProtocol; 539 public String PortNumber; 540 541 public RequiredProtoPortTuple() { 542 } 543 544 public RequiredProtoPortTuple(String nn, String protocol, String port) { 545 nodeName = nn; 546 IPProtocol = protocol; 547 PortNumber = port; 548 } 549 550 public RequiredProtoPortTuple(Parcel in) { 551 readFromParcel(in); 552 } 553 554 public int describeContents() { 555 return 0; 556 } 557 558 public void writeToParcel(Parcel out, int flags) { 559 out.writeString(nodeName); 560 out.writeString(IPProtocol); 561 out.writeString(PortNumber); 562 } 563 564 public void readFromParcel(Parcel in) { 565 if (in == null) { 566 //log here 567 } else { 568 nodeName = in.readString(); 569 IPProtocol = in.readString(); 570 PortNumber = in.readString(); 571 } 572 } 573 574 public static final Parcelable.Creator<RequiredProtoPortTuple> CREATOR = new Parcelable.Creator<RequiredProtoPortTuple>() { 575 public RequiredProtoPortTuple createFromParcel(Parcel in) { 576 return new RequiredProtoPortTuple(in); 577 } 578 579 public RequiredProtoPortTuple[] newArray(int size) { 580 return new RequiredProtoPortTuple[size]; 581 } 582 }; 583 } 584 585 /** 586 * PerProviderSubscription/<X+>/AAAServerTrustRoot 587 **/ 588 public static class AAAServerTrustRoot implements Parcelable { 589 public String nodeName; 590 public String CertURL; 591 public String CertSHA256Fingerprint; 592 593 public AAAServerTrustRoot(String nn, String url, String fp) { 594 nodeName = nn; 595 CertURL = url; 596 CertSHA256Fingerprint = fp; 597 } 598 599 public AAAServerTrustRoot() { 600 } 601 602 public AAAServerTrustRoot(Parcel in) { 603 readFromParcel(in); 604 } 605 606 public int describeContents() { 607 return 0; 608 } 609 610 public void writeToParcel(Parcel out, int flags) { 611 out.writeString(nodeName); 612 out.writeString(CertURL); 613 out.writeString(CertSHA256Fingerprint); 614 } 615 616 public void readFromParcel(Parcel in) { 617 if (in == null) { 618 //log here 619 } else { 620 nodeName = in.readString(); 621 CertURL = in.readString(); 622 CertSHA256Fingerprint = in.readString(); 623 } 624 } 625 626 public static final Parcelable.Creator<AAAServerTrustRoot> CREATOR = new Parcelable.Creator<AAAServerTrustRoot>() { 627 public AAAServerTrustRoot createFromParcel(Parcel in) { 628 return new AAAServerTrustRoot(in); 629 } 630 631 public AAAServerTrustRoot[] newArray(int size) { 632 return new AAAServerTrustRoot[size]; 633 } 634 }; 635 } 636 637 /** 638 * PerProviderSubscription/<X+>/SubscriptionUpdate 639 **/ 640 public static class SubscriptionUpdate implements Parcelable { 641 public String UpdateInterval; 642 public String UpdateMethod; 643 public String Restriction; 644 public String URI; 645 public UsernamePassword usernamePassword = new UsernamePassword(); 646 public String Other; 647 public TrustRoot trustRoot = new TrustRoot(); 648 649 public SubscriptionUpdate() { 650 } 651 652 public SubscriptionUpdate(Parcel in) { 653 readFromParcel(in); 654 } 655 656 public int describeContents() { 657 return 0; 658 } 659 660 public void writeToParcel(Parcel out, int flags) { 661 out.writeString(UpdateInterval); 662 out.writeString(UpdateMethod); 663 out.writeString(Restriction); 664 out.writeString(URI); 665 out.writeParcelable(usernamePassword, flags); 666 out.writeString(Other); 667 out.writeParcelable(trustRoot, flags); 668 } 669 670 public void readFromParcel(Parcel in) { 671 if (in == null) { 672 //log here 673 } else { 674 UpdateInterval = in.readString(); 675 UpdateMethod = in.readString(); 676 Restriction = in.readString(); 677 URI = in.readString(); 678 usernamePassword = in.readParcelable(UsernamePassword.class.getClassLoader()); 679 Other = in.readString(); 680 trustRoot = in.readParcelable(TrustRoot.class.getClassLoader()); 681 } 682 } 683 684 public static final Parcelable.Creator<SubscriptionUpdate> CREATOR = new Parcelable.Creator<SubscriptionUpdate>() { 685 public SubscriptionUpdate createFromParcel(Parcel in) { 686 return new SubscriptionUpdate(in); 687 } 688 689 public SubscriptionUpdate[] newArray(int size) { 690 return new SubscriptionUpdate[size]; 691 } 692 }; 693 694 } 695 696 /** 697 * PerProviderSubscription/<X+>/Policy/PolicyUpdate/TrustRoot 698 * PerProviderSubscription/<X+>/SubscriptionUpdate/TrustRoot 699 * PerProviderSubscription/<X+>/AAAServerTrustRoot/<X+> 700 **/ 701 public static class TrustRoot implements Parcelable { 702 public String CertURL; 703 public String CertSHA256Fingerprint; 704 705 public TrustRoot() { 706 } 707 708 public TrustRoot(Parcel in) { 709 readFromParcel(in); 710 } 711 712 public int describeContents() { 713 return 0; 714 } 715 716 public void writeToParcel(Parcel out, int flags) { 717 out.writeString(CertURL); 718 out.writeString(CertSHA256Fingerprint); 719 } 720 721 public void readFromParcel(Parcel in) { 722 if (in == null) { 723 //log here 724 } else { 725 CertURL = in.readString(); 726 CertSHA256Fingerprint = in.readString(); 727 } 728 } 729 730 public static final Parcelable.Creator<TrustRoot> CREATOR = new Parcelable.Creator<TrustRoot>() { 731 public TrustRoot createFromParcel(Parcel in) { 732 return new TrustRoot(in); 733 } 734 735 public TrustRoot[] newArray(int size) { 736 return new TrustRoot[size]; 737 } 738 }; 739 } 740 741 /** 742 * PerProviderSubscription/<X+>/Policy/PolicyUpdate/UsernamePassword 743 * PerProviderSubscription/<X+>/SubscriptionUpdate/UsernamePassword 744 * PerProviderSubscription/<X+>/Credential/UsernamePassword 745 **/ 746 public static class UsernamePassword implements Parcelable { 747 public String Username; 748 public String Password; 749 //following are Credential node used only 750 public boolean MachineManaged; 751 public String SoftTokenApp; 752 public String AbleToShare; 753 public EAPMethod eAPMethod = new EAPMethod(); 754 755 public UsernamePassword() { 756 } 757 758 public UsernamePassword(Parcel in) { 759 readFromParcel(in); 760 } 761 762 public int describeContents() { 763 return 0; 764 } 765 766 public void writeToParcel(Parcel out, int flags) { 767 out.writeString(Username); 768 out.writeString(Password); 769 out.writeInt(MachineManaged ? 1 : 0); 770 out.writeString(SoftTokenApp); 771 out.writeString(AbleToShare); 772 out.writeParcelable(eAPMethod, flags); 773 } 774 775 public void readFromParcel(Parcel in) { 776 if (in == null) { 777 //log here 778 } else { 779 Username = in.readString(); 780 Password = in.readString(); 781 MachineManaged = (in.readInt() == 1) ? true : false; 782 SoftTokenApp = in.readString(); 783 AbleToShare = in.readString(); 784 eAPMethod = in.readParcelable(EAPMethod.class.getClassLoader()); 785 } 786 } 787 788 public static final Parcelable.Creator<UsernamePassword> CREATOR = new Parcelable.Creator<UsernamePassword>() { 789 public UsernamePassword createFromParcel(Parcel in) { 790 return new UsernamePassword(in); 791 } 792 793 public UsernamePassword[] newArray(int size) { 794 return new UsernamePassword[size]; 795 } 796 }; 797 798 } 799 800 /** 801 * PerProviderSubscription/<X+>/Credential/UsernamePassword/EAPMethod 802 **/ 803 public static class EAPMethod implements Parcelable { 804 public String EAPType; 805 public String VendorId; 806 public String VendorType; 807 public String InnerEAPType; 808 public String InnerVendorId; 809 public String InnerVendorType; 810 public String InnerMethod; 811 812 public EAPMethod() { 813 } 814 815 public EAPMethod(Parcel in) { 816 readFromParcel(in); 817 } 818 819 public int describeContents() { 820 return 0; 821 } 822 823 public void writeToParcel(Parcel out, int flags) { 824 out.writeString(EAPType); 825 out.writeString(VendorId); 826 out.writeString(VendorType); 827 out.writeString(InnerEAPType); 828 out.writeString(InnerVendorId); 829 out.writeString(InnerVendorType); 830 out.writeString(InnerMethod); 831 } 832 833 public void readFromParcel(Parcel in) { 834 if (in == null) { 835 //log here 836 } else { 837 EAPType = in.readString(); 838 VendorId = in.readString(); 839 VendorType = in.readString(); 840 InnerEAPType = in.readString(); 841 InnerVendorId = in.readString(); 842 InnerVendorType = in.readString(); 843 InnerMethod = in.readString(); 844 } 845 } 846 847 public static final Parcelable.Creator<EAPMethod> CREATOR = new Parcelable.Creator<EAPMethod>() { 848 public EAPMethod createFromParcel(Parcel in) { 849 return new EAPMethod(in); 850 } 851 852 public EAPMethod[] newArray(int size) { 853 return new EAPMethod[size]; 854 } 855 }; 856 } 857 858 /** 859 * PerProviderSubscription/<X+>/HomeSP 860 **/ 861 public static class HomeSP implements Parcelable { 862 public HashMap<String, NetworkID> networkID = new HashMap<String, NetworkID>(); 863 public String FriendlyName; 864 public String IconURL; 865 public String FQDN; 866 public HashMap<String, HomeOIList> homeOIList = new HashMap<String, HomeOIList>(); 867 public HashMap<String, OtherHomePartners> otherHomePartners = new HashMap<String, OtherHomePartners>(); 868 public String RoamingConsortiumOI; 869 870 public NetworkID createNetworkID(String name, String ssid, String hessid) { 871 NetworkID obj = new NetworkID(name, ssid, hessid); 872 networkID.put(name, obj); 873 return obj; 874 } 875 876 public HomeOIList createHomeOIList(String name, String homeoi, boolean required) { 877 HomeOIList obj = new HomeOIList(name, homeoi, required); 878 homeOIList.put(name, obj); 879 return obj; 880 } 881 882 public OtherHomePartners createOtherHomePartners(String name, String fqdn) { 883 OtherHomePartners obj = new OtherHomePartners(name, fqdn); 884 otherHomePartners.put(name, obj); 885 return obj; 886 } 887 888 public HomeSP() { 889 } 890 891 public HomeSP(Parcel in) { 892 readFromParcel(in); 893 } 894 895 public int describeContents() { 896 return 0; 897 } 898 899 public void writeToParcel(Parcel out, int flags) { 900 out.writeMap(networkID); 901 out.writeString(FriendlyName); 902 out.writeString(IconURL); 903 out.writeString(FQDN); 904 out.writeMap(homeOIList); 905 out.writeMap(otherHomePartners); 906 out.writeString(RoamingConsortiumOI); 907 } 908 909 public void readFromParcel(Parcel in) { 910 if (in == null) { 911 //log here 912 } else { 913 in.readMap(networkID, NetworkID.class.getClassLoader()); 914 FriendlyName = in.readString(); 915 IconURL = in.readString(); 916 FQDN = in.readString(); 917 in.readMap(homeOIList, HomeOIList.class.getClassLoader()); 918 in.readMap(otherHomePartners, OtherHomePartners.class.getClassLoader()); 919 RoamingConsortiumOI = in.readString(); 920 } 921 } 922 923 public static final Parcelable.Creator<HomeSP> CREATOR = new Parcelable.Creator<HomeSP>() { 924 public HomeSP createFromParcel(Parcel in) { 925 return new HomeSP(in); 926 } 927 928 public HomeSP[] newArray(int size) { 929 return new HomeSP[size]; 930 } 931 }; 932 933 } 934 935 /** 936 * PerProviderSubscription/<X+>/HomeSP/NetworkID 937 **/ 938 public static class NetworkID implements Parcelable { 939 public String nodeName; 940 public String SSID; 941 public String HESSID; 942 943 public NetworkID(String nn, String s, String h) { 944 nodeName = nn; 945 SSID = s; 946 HESSID = h; 947 } 948 949 public NetworkID() { 950 } 951 952 public NetworkID(Parcel in) { 953 readFromParcel(in); 954 } 955 956 public int describeContents() { 957 return 0; 958 } 959 960 public void writeToParcel(Parcel out, int flags) { 961 out.writeString(nodeName); 962 out.writeString(SSID); 963 out.writeString(HESSID); 964 } 965 966 public void readFromParcel(Parcel in) { 967 if (in == null) { 968 //log here 969 } else { 970 nodeName = in.readString(); 971 SSID = in.readString(); 972 HESSID = in.readString(); 973 } 974 } 975 976 public static final Parcelable.Creator<NetworkID> CREATOR = new Parcelable.Creator<NetworkID>() { 977 public NetworkID createFromParcel(Parcel in) { 978 return new NetworkID(in); 979 } 980 981 public NetworkID[] newArray(int size) { 982 return new NetworkID[size]; 983 } 984 }; 985 986 } 987 988 /** 989 * PerProviderSubscription/<X+>/HomeSP/HomeOIList 990 **/ 991 public static class HomeOIList implements Parcelable { 992 public String nodeName; 993 public String HomeOI; 994 public boolean HomeOIRequired; 995 996 public HomeOIList(String nn, String h, boolean r) { 997 nodeName = nn; 998 HomeOI = h; 999 HomeOIRequired = r; 1000 } 1001 1002 public HomeOIList() { 1003 } 1004 1005 public HomeOIList(Parcel in) { 1006 readFromParcel(in); 1007 } 1008 1009 public int describeContents() { 1010 return 0; 1011 } 1012 1013 public void writeToParcel(Parcel out, int flags) { 1014 out.writeString(nodeName); 1015 out.writeString(HomeOI); 1016 out.writeInt(HomeOIRequired ? 1 : 0); 1017 } 1018 1019 public void readFromParcel(Parcel in) { 1020 if (in == null) { 1021 //log here 1022 } else { 1023 nodeName = in.readString(); 1024 HomeOI = in.readString(); 1025 HomeOIRequired = (in.readInt() == 1) ? true : false; 1026 } 1027 } 1028 1029 public static final Parcelable.Creator<HomeOIList> CREATOR = new Parcelable.Creator<HomeOIList>() { 1030 public HomeOIList createFromParcel(Parcel in) { 1031 return new HomeOIList(in); 1032 } 1033 1034 public HomeOIList[] newArray(int size) { 1035 return new HomeOIList[size]; 1036 } 1037 }; 1038 1039 } 1040 1041 /** 1042 * PerProviderSubscription/<X+>/HomeSP/OtherHomePartners 1043 **/ 1044 public static class OtherHomePartners implements Parcelable { 1045 public String nodeName; 1046 public String FQDN; 1047 1048 public OtherHomePartners(String nn, String f) { 1049 nodeName = nn; 1050 FQDN = f; 1051 } 1052 1053 public OtherHomePartners() { 1054 } 1055 1056 public OtherHomePartners(Parcel in) { 1057 readFromParcel(in); 1058 } 1059 1060 public int describeContents() { 1061 return 0; 1062 } 1063 1064 public void writeToParcel(Parcel out, int flags) { 1065 out.writeString(nodeName); 1066 out.writeString(FQDN); 1067 } 1068 1069 public void readFromParcel(Parcel in) { 1070 if (in == null) { 1071 //log here 1072 } else { 1073 nodeName = in.readString(); 1074 FQDN = in.readString(); 1075 } 1076 } 1077 1078 public static final Parcelable.Creator<OtherHomePartners> CREATOR = new Parcelable.Creator<OtherHomePartners>() { 1079 public OtherHomePartners createFromParcel(Parcel in) { 1080 return new OtherHomePartners(in); 1081 } 1082 1083 public OtherHomePartners[] newArray(int size) { 1084 return new OtherHomePartners[size]; 1085 } 1086 }; 1087 1088 } 1089 1090 /** 1091 * PerProviderSubscription/<X+>/SubscriptionParameters 1092 **/ 1093 public static class SubscriptionParameters implements Parcelable { 1094 public String CreationDate; 1095 public String ExpirationDate; 1096 public String TypeOfSubscription; 1097 public UsageLimits usageLimits = new UsageLimits(); 1098 1099 public SubscriptionParameters() { 1100 } 1101 1102 public SubscriptionParameters(Parcel in) { 1103 readFromParcel(in); 1104 } 1105 1106 public int describeContents() { 1107 return 0; 1108 } 1109 1110 public void writeToParcel(Parcel out, int flags) { 1111 out.writeString(CreationDate); 1112 out.writeString(ExpirationDate); 1113 out.writeString(TypeOfSubscription); 1114 out.writeParcelable(usageLimits, flags); 1115 } 1116 1117 public void readFromParcel(Parcel in) { 1118 if (in == null) { 1119 //log here 1120 } else { 1121 CreationDate = in.readString(); 1122 ExpirationDate = in.readString(); 1123 TypeOfSubscription = in.readString(); 1124 usageLimits = in.readParcelable(UsageLimits.class.getClassLoader()); 1125 } 1126 } 1127 1128 public static final Parcelable.Creator<SubscriptionParameters> CREATOR = new Parcelable.Creator<SubscriptionParameters>() { 1129 public SubscriptionParameters createFromParcel(Parcel in) { 1130 return new SubscriptionParameters(in); 1131 } 1132 1133 public SubscriptionParameters[] newArray(int size) { 1134 return new SubscriptionParameters[size]; 1135 } 1136 }; 1137 1138 } 1139 1140 /** 1141 * PerProviderSubscription/<X+>/SubscriptionParameters/UsageLimits 1142 **/ 1143 public static class UsageLimits implements Parcelable { 1144 public String DataLimit; 1145 public String StartDate; 1146 public String TimeLimit; 1147 public String UsageTimePeriod; 1148 1149 public UsageLimits() { 1150 } 1151 1152 public UsageLimits(Parcel in) { 1153 readFromParcel(in); 1154 } 1155 1156 public int describeContents() { 1157 return 0; 1158 } 1159 1160 public void writeToParcel(Parcel out, int flags) { 1161 out.writeString(DataLimit); 1162 out.writeString(StartDate); 1163 out.writeString(TimeLimit); 1164 out.writeString(UsageTimePeriod); 1165 } 1166 1167 public void readFromParcel(Parcel in) { 1168 if (in == null) { 1169 //log here 1170 } else { 1171 DataLimit = in.readString(); 1172 StartDate = in.readString(); 1173 TimeLimit = in.readString(); 1174 UsageTimePeriod = in.readString(); 1175 } 1176 } 1177 1178 public static final Parcelable.Creator<UsageLimits> CREATOR = new Parcelable.Creator<UsageLimits>() { 1179 public UsageLimits createFromParcel(Parcel in) { 1180 return new UsageLimits(in); 1181 } 1182 1183 public UsageLimits[] newArray(int size) { 1184 return new UsageLimits[size]; 1185 } 1186 }; 1187 } 1188 1189 /** 1190 * PerProviderSubscription/<X+>/Credential 1191 **/ 1192 public static class Credential implements Parcelable { 1193 public String CreationDate; 1194 public String ExpirationDate; 1195 public UsernamePassword usernamePassword = new UsernamePassword(); 1196 public DigitalCertificate digitalCertificate = new DigitalCertificate(); 1197 public String Realm; 1198 public boolean CheckAAAServerCertStatus; 1199 public SIM sim = new SIM(); 1200 1201 public Credential() { 1202 } 1203 1204 public Credential(Parcel in) { 1205 readFromParcel(in); 1206 } 1207 1208 public int describeContents() { 1209 return 0; 1210 } 1211 1212 public void writeToParcel(Parcel out, int flags) { 1213 out.writeString(CreationDate); 1214 out.writeString(ExpirationDate); 1215 out.writeParcelable(usernamePassword, flags); 1216 out.writeParcelable(digitalCertificate, flags); 1217 out.writeString(Realm); 1218 out.writeInt(CheckAAAServerCertStatus ? 1 : 0); 1219 out.writeParcelable(sim, flags); 1220 } 1221 1222 public void readFromParcel(Parcel in) { 1223 if (in == null) { 1224 //log here 1225 } else { 1226 CreationDate = in.readString(); 1227 ExpirationDate = in.readString(); 1228 usernamePassword = in.readParcelable(UsernamePassword.class.getClassLoader()); 1229 digitalCertificate = in.readParcelable(DigitalCertificate.class.getClassLoader()); 1230 Realm = in.readString(); 1231 CheckAAAServerCertStatus = (in.readInt() == 1) ? true : false; 1232 sim = in.readParcelable(SIM.class.getClassLoader()); 1233 } 1234 } 1235 1236 public static final Parcelable.Creator<Credential> CREATOR = new Parcelable.Creator<Credential>() { 1237 public Credential createFromParcel(Parcel in) { 1238 return new Credential(in); 1239 } 1240 1241 public Credential[] newArray(int size) { 1242 return new Credential[size]; 1243 } 1244 }; 1245 } 1246 1247 /** 1248 * PerProviderSubscription/<X+>/Credential/DigitalCertificate 1249 **/ 1250 public static class DigitalCertificate implements Parcelable { 1251 public String CertificateType; 1252 public String CertSHA256Fingerprint; 1253 1254 public DigitalCertificate() { 1255 } 1256 1257 public DigitalCertificate(Parcel in) { 1258 readFromParcel(in); 1259 } 1260 1261 public int describeContents() { 1262 return 0; 1263 } 1264 1265 public void writeToParcel(Parcel out, int flags) { 1266 out.writeString(CertificateType); 1267 out.writeString(CertSHA256Fingerprint); 1268 } 1269 1270 public void readFromParcel(Parcel in) { 1271 if (in == null) { 1272 //log here 1273 } else { 1274 CertificateType = in.readString(); 1275 CertSHA256Fingerprint = in.readString(); 1276 } 1277 } 1278 1279 public static final Parcelable.Creator<DigitalCertificate> CREATOR = new Parcelable.Creator<DigitalCertificate>() { 1280 public DigitalCertificate createFromParcel(Parcel in) { 1281 return new DigitalCertificate(in); 1282 } 1283 1284 public DigitalCertificate[] newArray(int size) { 1285 return new DigitalCertificate[size]; 1286 } 1287 }; 1288 1289 } 1290 1291 /** 1292 * PerProviderSubscription/<X+>/Credential/SIM 1293 **/ 1294 public static class SIM implements Parcelable { 1295 public String IMSI; 1296 public String EAPType; 1297 1298 public SIM() { 1299 } 1300 1301 public SIM(Parcel in) { 1302 readFromParcel(in); 1303 } 1304 1305 public int describeContents() { 1306 return 0; 1307 } 1308 1309 public void writeToParcel(Parcel out, int flags) { 1310 out.writeString(IMSI); 1311 out.writeString(EAPType); 1312 } 1313 1314 public void readFromParcel(Parcel in) { 1315 if (in == null) { 1316 //log here 1317 } else { 1318 IMSI = in.readString(); 1319 EAPType = in.readString(); 1320 } 1321 } 1322 1323 public static final Parcelable.Creator<SIM> CREATOR = new Parcelable.Creator<SIM>() { 1324 public SIM createFromParcel(Parcel in) { 1325 return new SIM(in); 1326 } 1327 1328 public SIM[] newArray(int size) { 1329 return new SIM[size]; 1330 } 1331 }; 1332 1333 } 1334 1335 /** 1336 * PerProviderSubscription/<X+>/Extension 1337 **/ 1338 public static class Extension { 1339 public String empty; 1340 } 1341 1342 public WifiPasspointDmTree() { 1343 } 1344 1345 public WifiPasspointDmTree(Parcel in) { 1346 readFromParcel(in); 1347 } 1348 1349 public int describeContents() { 1350 return 0; 1351 } 1352 1353 public void writeToParcel(Parcel out, int flags) { 1354 out.writeMap(spFqdn); 1355 } 1356 1357 public void readFromParcel(Parcel in) { 1358 if (in == null) { 1359 //log here 1360 } else { 1361 in.readMap(spFqdn, SpFqdn.class.getClassLoader()); 1362 } 1363 } 1364 1365 public static final Parcelable.Creator<WifiPasspointDmTree> CREATOR = new Parcelable.Creator<WifiPasspointDmTree>() { 1366 public WifiPasspointDmTree createFromParcel(Parcel in) { 1367 return new WifiPasspointDmTree(in); 1368 } 1369 1370 public WifiPasspointDmTree[] newArray(int size) { 1371 return new WifiPasspointDmTree[size]; 1372 } 1373 }; 1374 1375} 1376