| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.net.wifi.passpoint; |
| |
| import android.os.Parcelable; |
| import android.os.Parcel; |
| import android.util.Log; |
| |
| import java.util.HashMap; |
| |
| /** |
| * Required Mobile Device Management Tree Structure |
| * |
| * +----------+ |
| * | ./(Root) | |
| * +----+-----+ |
| * | |
| * +---------+ | +---------+ +---------+ |
| * | DevInfo |-----------+---------| Wi-Fi |--|SP FQDN* | |
| * +---------+ | +---------+ +---------+ |
| * +---------+ | | |
| * |DevDetail|-----------+ +-----------------------+ |
| * +---------+ |PerproviderSubscription|--<X>+ |
| * +-----------------------+ |
| * |
| * This class contains all nodes start from Wi-Fi |
| * @hide |
| **/ |
| public class WifiPasspointDmTree implements Parcelable { |
| private final static String TAG = "WifiTree"; |
| public int PpsMoId;//plugfest used only |
| public HashMap<String, SpFqdn> spFqdn = new HashMap<String, SpFqdn>();//Maps.newHashMap(); |
| |
| public SpFqdn createSpFqdn(String name) { |
| SpFqdn obj = new SpFqdn(name); |
| spFqdn.put(name, obj); |
| return obj; |
| } |
| |
| public static class SpFqdn implements Parcelable { |
| public String nodeName; |
| public PerProviderSubscription perProviderSubscription = new PerProviderSubscription(); |
| |
| public SpFqdn(String name) { |
| nodeName = name; |
| } |
| |
| public SpFqdn() { |
| } |
| |
| public SpFqdn(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeParcelable(perProviderSubscription, flags); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| perProviderSubscription = in.readParcelable(PerProviderSubscription.class |
| .getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<SpFqdn> CREATOR = new Parcelable.Creator<SpFqdn>() { |
| public SpFqdn createFromParcel(Parcel in) { |
| return new SpFqdn(in); |
| } |
| |
| public SpFqdn[] newArray(int size) { |
| return new SpFqdn[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription |
| **/ |
| public static class PerProviderSubscription implements Parcelable { |
| /** |
| * PerProviderSubscription/UpdateIdentifier |
| **/ |
| public String UpdateIdentifier; |
| public HashMap<String, CredentialInfo> credentialInfo = new HashMap<String, CredentialInfo>(); |
| |
| public CredentialInfo createCredentialInfo(String name) { |
| CredentialInfo obj = new CredentialInfo(name); |
| credentialInfo.put(name, obj); |
| return obj; |
| } |
| |
| public PerProviderSubscription() { |
| } |
| |
| public PerProviderSubscription(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(UpdateIdentifier); |
| out.writeMap(credentialInfo); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| UpdateIdentifier = in.readString(); |
| in.readMap(credentialInfo, CredentialInfo.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<PerProviderSubscription> CREATOR = new Parcelable.Creator<PerProviderSubscription>() { |
| public PerProviderSubscription createFromParcel(Parcel in) { |
| return new PerProviderSubscription(in); |
| } |
| |
| public PerProviderSubscription[] newArray(int size) { |
| return new PerProviderSubscription[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+> |
| * This interior node contains the Home SP information, subscription policy, management and credential information. |
| **/ |
| public static class CredentialInfo implements Parcelable { |
| public String nodeName; |
| public Policy policy = new Policy(); |
| public String credentialPriority; |
| public HashMap<String, AAAServerTrustRoot> aAAServerTrustRoot = new HashMap<String, AAAServerTrustRoot>(); |
| public SubscriptionUpdate subscriptionUpdate = new SubscriptionUpdate(); |
| public HomeSP homeSP = new HomeSP(); |
| public SubscriptionParameters subscriptionParameters = new SubscriptionParameters(); |
| public Credential credential = new Credential(); |
| public Extension extension = new Extension(); |
| |
| public CredentialInfo(String nn) { |
| nodeName = nn; |
| } |
| |
| public AAAServerTrustRoot createAAAServerTrustRoot(String name, String url, String fp) { |
| AAAServerTrustRoot obj = new AAAServerTrustRoot(name, url, fp); |
| aAAServerTrustRoot.put(name, obj); |
| return obj; |
| } |
| |
| public CredentialInfo() { |
| } |
| |
| public CredentialInfo(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeParcelable(policy, flags); |
| out.writeString(credentialPriority); |
| out.writeMap(aAAServerTrustRoot); |
| out.writeParcelable(subscriptionUpdate, flags); |
| out.writeParcelable(homeSP, flags); |
| out.writeParcelable(subscriptionParameters, flags); |
| out.writeParcelable(credential, flags); |
| //out.writeParcelable(extension, flags); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| policy = in.readParcelable(Policy.class.getClassLoader()); |
| credentialPriority = in.readString(); |
| in.readMap(aAAServerTrustRoot, AAAServerTrustRoot.class.getClassLoader()); |
| subscriptionUpdate = in.readParcelable(SubscriptionUpdate.class.getClassLoader()); |
| homeSP = in.readParcelable(HomeSP.class.getClassLoader()); |
| subscriptionParameters = in.readParcelable(SubscriptionParameters.class |
| .getClassLoader()); |
| credential = in.readParcelable(Credential.class.getClassLoader()); |
| //extension = in.readParcelable(Extension.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<CredentialInfo> CREATOR = new Parcelable.Creator<CredentialInfo>() { |
| public CredentialInfo createFromParcel(Parcel in) { |
| return new CredentialInfo(in); |
| } |
| |
| public CredentialInfo[] newArray(int size) { |
| return new CredentialInfo[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy |
| **/ |
| public static class Policy implements Parcelable { |
| public HashMap<String, PreferredRoamingPartnerList> preferredRoamingPartnerList = new HashMap<String, PreferredRoamingPartnerList>(); |
| public HashMap<String, MinBackhaulThresholdNetwork> minBackhaulThreshold = new HashMap<String, MinBackhaulThresholdNetwork>(); |
| public PolicyUpdate policyUpdate = new PolicyUpdate(); |
| public HashMap<String, SPExclusionList> sPExclusionList = new HashMap<String, SPExclusionList>(); |
| public HashMap<String, RequiredProtoPortTuple> requiredProtoPortTuple = new HashMap<String, RequiredProtoPortTuple>(); |
| public String maximumBSSLoadValue; |
| |
| public PreferredRoamingPartnerList createPreferredRoamingPartnerList(String name, |
| String fqdn, String priority, String country) { |
| PreferredRoamingPartnerList obj = new PreferredRoamingPartnerList(name, fqdn, priority, |
| country); |
| preferredRoamingPartnerList.put(name, obj); |
| return obj; |
| } |
| |
| public MinBackhaulThresholdNetwork createMinBackhaulThreshold(String name, String type, |
| String dl, String ul) { |
| MinBackhaulThresholdNetwork obj = new MinBackhaulThresholdNetwork(name, type, dl, ul); |
| minBackhaulThreshold.put(name, obj); |
| return obj; |
| } |
| |
| public SPExclusionList createSPExclusionList(String name, String ssid) { |
| SPExclusionList obj = new SPExclusionList(name, ssid); |
| sPExclusionList.put(name, obj); |
| return obj; |
| } |
| |
| public RequiredProtoPortTuple createRequiredProtoPortTuple(String name, String proto, |
| String port) { |
| RequiredProtoPortTuple obj = new RequiredProtoPortTuple(name, proto, port); |
| requiredProtoPortTuple.put(name, obj); |
| return obj; |
| } |
| |
| public Policy() { |
| } |
| |
| public Policy(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeMap(preferredRoamingPartnerList); |
| out.writeMap(minBackhaulThreshold); |
| out.writeParcelable(policyUpdate, flags); |
| out.writeMap(sPExclusionList); |
| out.writeMap(requiredProtoPortTuple); |
| out.writeString(maximumBSSLoadValue); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| in.readMap(preferredRoamingPartnerList, |
| PreferredRoamingPartnerList.class.getClassLoader()); |
| in.readMap(minBackhaulThreshold, MinBackhaulThresholdNetwork.class.getClassLoader()); |
| policyUpdate = in.readParcelable(PolicyUpdate.class.getClassLoader()); |
| in.readMap(sPExclusionList, SPExclusionList.class.getClassLoader()); |
| in.readMap(requiredProtoPortTuple, RequiredProtoPortTuple.class.getClassLoader()); |
| maximumBSSLoadValue = in.readString(); |
| |
| } |
| } |
| |
| public static final Parcelable.Creator<Policy> CREATOR = new Parcelable.Creator<Policy>() { |
| public Policy createFromParcel(Parcel in) { |
| return new Policy(in); |
| } |
| |
| public Policy[] newArray(int size) { |
| return new Policy[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/PreferredRoamingPartnerList/<X+> |
| **/ |
| public static class PreferredRoamingPartnerList implements Parcelable { |
| public String nodeName; |
| public String FQDN_Match; //maximum 255 + ",includeSubdomains", equals 273 |
| public String Priority; |
| public String Country; // maximum 600 octets |
| |
| public PreferredRoamingPartnerList(String nn, String f, String p, String c) { |
| nodeName = nn; |
| FQDN_Match = f; |
| Priority = p; |
| Country = c; |
| } |
| |
| public PreferredRoamingPartnerList() { |
| } |
| |
| public PreferredRoamingPartnerList(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(FQDN_Match); |
| out.writeString(Priority); |
| out.writeString(Country); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| FQDN_Match = in.readString(); |
| Priority = in.readString(); |
| Country = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<PreferredRoamingPartnerList> CREATOR = new Parcelable.Creator<PreferredRoamingPartnerList>() { |
| public PreferredRoamingPartnerList createFromParcel(Parcel in) { |
| return new PreferredRoamingPartnerList(in); |
| } |
| |
| public PreferredRoamingPartnerList[] newArray(int size) { |
| return new PreferredRoamingPartnerList[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/MinBackhaulThreshold |
| **/ |
| public static class MinBackhaulThresholdNetwork implements Parcelable { |
| public String nodeName; |
| public String NetworkType; |
| public String DLBandwidth; |
| public String ULBandwidth; |
| |
| public MinBackhaulThresholdNetwork(String nn, String nt, String d, String u) { |
| nodeName = nn; |
| NetworkType = nt; |
| DLBandwidth = d; |
| ULBandwidth = u; |
| } |
| |
| public MinBackhaulThresholdNetwork() { |
| } |
| |
| public MinBackhaulThresholdNetwork(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(NetworkType); |
| out.writeString(DLBandwidth); |
| out.writeString(ULBandwidth); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| NetworkType = in.readString(); |
| DLBandwidth = in.readString(); |
| ULBandwidth = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<MinBackhaulThresholdNetwork> CREATOR = new Parcelable.Creator<MinBackhaulThresholdNetwork>() { |
| public MinBackhaulThresholdNetwork createFromParcel(Parcel in) { |
| return new MinBackhaulThresholdNetwork(in); |
| } |
| |
| public MinBackhaulThresholdNetwork[] newArray(int size) { |
| return new MinBackhaulThresholdNetwork[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/PolicyUpdate |
| **/ |
| public static class PolicyUpdate implements Parcelable { |
| public String UpdateInterval; |
| public String UpdateMethod; |
| public String Restriction; |
| public String URI; |
| public UsernamePassword usernamePassword = new UsernamePassword(); |
| public String Other; |
| public TrustRoot trustRoot = new TrustRoot(); |
| |
| public PolicyUpdate() { |
| } |
| |
| public PolicyUpdate(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(UpdateInterval); |
| out.writeString(UpdateMethod); |
| out.writeString(Restriction); |
| out.writeString(URI); |
| out.writeParcelable(usernamePassword, flags); |
| out.writeString(Other); |
| out.writeParcelable(trustRoot, flags); |
| |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| UpdateInterval = in.readString(); |
| UpdateMethod = in.readString(); |
| Restriction = in.readString(); |
| URI = in.readString(); |
| usernamePassword = in.readParcelable(UsernamePassword.class.getClassLoader()); |
| Other = in.readString(); |
| trustRoot = in.readParcelable(TrustRoot.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<PolicyUpdate> CREATOR = new Parcelable.Creator<PolicyUpdate>() { |
| public PolicyUpdate createFromParcel(Parcel in) { |
| return new PolicyUpdate(in); |
| } |
| |
| public PolicyUpdate[] newArray(int size) { |
| return new PolicyUpdate[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/SPExclusionList |
| **/ |
| public static class SPExclusionList implements Parcelable { |
| public String nodeName; |
| public String SSID; |
| |
| public SPExclusionList(String nn, String s) { |
| nodeName = nn; |
| SSID = s; |
| } |
| |
| public SPExclusionList() { |
| } |
| |
| public SPExclusionList(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(SSID); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| SSID = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<SPExclusionList> CREATOR = new Parcelable.Creator<SPExclusionList>() { |
| public SPExclusionList createFromParcel(Parcel in) { |
| return new SPExclusionList(in); |
| } |
| |
| public SPExclusionList[] newArray(int size) { |
| return new SPExclusionList[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/RequiredProtoPortTuple |
| **/ |
| public static class RequiredProtoPortTuple implements Parcelable { |
| public String nodeName; |
| public String IPProtocol; |
| public String PortNumber; |
| |
| public RequiredProtoPortTuple() { |
| } |
| |
| public RequiredProtoPortTuple(String nn, String protocol, String port) { |
| nodeName = nn; |
| IPProtocol = protocol; |
| PortNumber = port; |
| } |
| |
| public RequiredProtoPortTuple(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(IPProtocol); |
| out.writeString(PortNumber); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| IPProtocol = in.readString(); |
| PortNumber = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<RequiredProtoPortTuple> CREATOR = new Parcelable.Creator<RequiredProtoPortTuple>() { |
| public RequiredProtoPortTuple createFromParcel(Parcel in) { |
| return new RequiredProtoPortTuple(in); |
| } |
| |
| public RequiredProtoPortTuple[] newArray(int size) { |
| return new RequiredProtoPortTuple[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/AAAServerTrustRoot |
| **/ |
| public static class AAAServerTrustRoot implements Parcelable { |
| public String nodeName; |
| public String CertURL; |
| public String CertSHA256Fingerprint; |
| |
| public AAAServerTrustRoot(String nn, String url, String fp) { |
| nodeName = nn; |
| CertURL = url; |
| CertSHA256Fingerprint = fp; |
| } |
| |
| public AAAServerTrustRoot() { |
| } |
| |
| public AAAServerTrustRoot(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(CertURL); |
| out.writeString(CertSHA256Fingerprint); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| CertURL = in.readString(); |
| CertSHA256Fingerprint = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<AAAServerTrustRoot> CREATOR = new Parcelable.Creator<AAAServerTrustRoot>() { |
| public AAAServerTrustRoot createFromParcel(Parcel in) { |
| return new AAAServerTrustRoot(in); |
| } |
| |
| public AAAServerTrustRoot[] newArray(int size) { |
| return new AAAServerTrustRoot[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/SubscriptionUpdate |
| **/ |
| public static class SubscriptionUpdate implements Parcelable { |
| public String UpdateInterval; |
| public String UpdateMethod; |
| public String Restriction; |
| public String URI; |
| public UsernamePassword usernamePassword = new UsernamePassword(); |
| public String Other; |
| public TrustRoot trustRoot = new TrustRoot(); |
| |
| public SubscriptionUpdate() { |
| } |
| |
| public SubscriptionUpdate(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(UpdateInterval); |
| out.writeString(UpdateMethod); |
| out.writeString(Restriction); |
| out.writeString(URI); |
| out.writeParcelable(usernamePassword, flags); |
| out.writeString(Other); |
| out.writeParcelable(trustRoot, flags); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| UpdateInterval = in.readString(); |
| UpdateMethod = in.readString(); |
| Restriction = in.readString(); |
| URI = in.readString(); |
| usernamePassword = in.readParcelable(UsernamePassword.class.getClassLoader()); |
| Other = in.readString(); |
| trustRoot = in.readParcelable(TrustRoot.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<SubscriptionUpdate> CREATOR = new Parcelable.Creator<SubscriptionUpdate>() { |
| public SubscriptionUpdate createFromParcel(Parcel in) { |
| return new SubscriptionUpdate(in); |
| } |
| |
| public SubscriptionUpdate[] newArray(int size) { |
| return new SubscriptionUpdate[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/PolicyUpdate/TrustRoot |
| * PerProviderSubscription/<X+>/SubscriptionUpdate/TrustRoot |
| * PerProviderSubscription/<X+>/AAAServerTrustRoot/<X+> |
| **/ |
| public static class TrustRoot implements Parcelable { |
| public String CertURL; |
| public String CertSHA256Fingerprint; |
| |
| public TrustRoot() { |
| } |
| |
| public TrustRoot(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(CertURL); |
| out.writeString(CertSHA256Fingerprint); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| CertURL = in.readString(); |
| CertSHA256Fingerprint = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<TrustRoot> CREATOR = new Parcelable.Creator<TrustRoot>() { |
| public TrustRoot createFromParcel(Parcel in) { |
| return new TrustRoot(in); |
| } |
| |
| public TrustRoot[] newArray(int size) { |
| return new TrustRoot[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Policy/PolicyUpdate/UsernamePassword |
| * PerProviderSubscription/<X+>/SubscriptionUpdate/UsernamePassword |
| * PerProviderSubscription/<X+>/Credential/UsernamePassword |
| **/ |
| public static class UsernamePassword implements Parcelable { |
| public String Username; |
| public String Password; |
| //following are Credential node used only |
| public boolean MachineManaged; |
| public String SoftTokenApp; |
| public String AbleToShare; |
| public EAPMethod eAPMethod = new EAPMethod(); |
| |
| public UsernamePassword() { |
| } |
| |
| public UsernamePassword(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(Username); |
| out.writeString(Password); |
| out.writeInt(MachineManaged ? 1 : 0); |
| out.writeString(SoftTokenApp); |
| out.writeString(AbleToShare); |
| out.writeParcelable(eAPMethod, flags); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| Username = in.readString(); |
| Password = in.readString(); |
| MachineManaged = (in.readInt() == 1) ? true : false; |
| SoftTokenApp = in.readString(); |
| AbleToShare = in.readString(); |
| eAPMethod = in.readParcelable(EAPMethod.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<UsernamePassword> CREATOR = new Parcelable.Creator<UsernamePassword>() { |
| public UsernamePassword createFromParcel(Parcel in) { |
| return new UsernamePassword(in); |
| } |
| |
| public UsernamePassword[] newArray(int size) { |
| return new UsernamePassword[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Credential/UsernamePassword/EAPMethod |
| **/ |
| public static class EAPMethod implements Parcelable { |
| public String EAPType; |
| public String VendorId; |
| public String VendorType; |
| public String InnerEAPType; |
| public String InnerVendorId; |
| public String InnerVendorType; |
| public String InnerMethod; |
| |
| public EAPMethod() { |
| } |
| |
| public EAPMethod(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(EAPType); |
| out.writeString(VendorId); |
| out.writeString(VendorType); |
| out.writeString(InnerEAPType); |
| out.writeString(InnerVendorId); |
| out.writeString(InnerVendorType); |
| out.writeString(InnerMethod); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| EAPType = in.readString(); |
| VendorId = in.readString(); |
| VendorType = in.readString(); |
| InnerEAPType = in.readString(); |
| InnerVendorId = in.readString(); |
| InnerVendorType = in.readString(); |
| InnerMethod = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<EAPMethod> CREATOR = new Parcelable.Creator<EAPMethod>() { |
| public EAPMethod createFromParcel(Parcel in) { |
| return new EAPMethod(in); |
| } |
| |
| public EAPMethod[] newArray(int size) { |
| return new EAPMethod[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/HomeSP |
| **/ |
| public static class HomeSP implements Parcelable { |
| public HashMap<String, NetworkID> networkID = new HashMap<String, NetworkID>(); |
| public String FriendlyName; |
| public String IconURL; |
| public String FQDN; |
| public HashMap<String, HomeOIList> homeOIList = new HashMap<String, HomeOIList>(); |
| public HashMap<String, OtherHomePartners> otherHomePartners = new HashMap<String, OtherHomePartners>(); |
| public String RoamingConsortiumOI; |
| |
| public NetworkID createNetworkID(String name, String ssid, String hessid) { |
| NetworkID obj = new NetworkID(name, ssid, hessid); |
| networkID.put(name, obj); |
| return obj; |
| } |
| |
| public HomeOIList createHomeOIList(String name, String homeoi, boolean required) { |
| HomeOIList obj = new HomeOIList(name, homeoi, required); |
| homeOIList.put(name, obj); |
| return obj; |
| } |
| |
| public OtherHomePartners createOtherHomePartners(String name, String fqdn) { |
| OtherHomePartners obj = new OtherHomePartners(name, fqdn); |
| otherHomePartners.put(name, obj); |
| return obj; |
| } |
| |
| public HomeSP() { |
| } |
| |
| public HomeSP(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeMap(networkID); |
| out.writeString(FriendlyName); |
| out.writeString(IconURL); |
| out.writeString(FQDN); |
| out.writeMap(homeOIList); |
| out.writeMap(otherHomePartners); |
| out.writeString(RoamingConsortiumOI); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| in.readMap(networkID, NetworkID.class.getClassLoader()); |
| FriendlyName = in.readString(); |
| IconURL = in.readString(); |
| FQDN = in.readString(); |
| in.readMap(homeOIList, HomeOIList.class.getClassLoader()); |
| in.readMap(otherHomePartners, OtherHomePartners.class.getClassLoader()); |
| RoamingConsortiumOI = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<HomeSP> CREATOR = new Parcelable.Creator<HomeSP>() { |
| public HomeSP createFromParcel(Parcel in) { |
| return new HomeSP(in); |
| } |
| |
| public HomeSP[] newArray(int size) { |
| return new HomeSP[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/HomeSP/NetworkID |
| **/ |
| public static class NetworkID implements Parcelable { |
| public String nodeName; |
| public String SSID; |
| public String HESSID; |
| |
| public NetworkID(String nn, String s, String h) { |
| nodeName = nn; |
| SSID = s; |
| HESSID = h; |
| } |
| |
| public NetworkID() { |
| } |
| |
| public NetworkID(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(SSID); |
| out.writeString(HESSID); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| SSID = in.readString(); |
| HESSID = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<NetworkID> CREATOR = new Parcelable.Creator<NetworkID>() { |
| public NetworkID createFromParcel(Parcel in) { |
| return new NetworkID(in); |
| } |
| |
| public NetworkID[] newArray(int size) { |
| return new NetworkID[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/HomeSP/HomeOIList |
| **/ |
| public static class HomeOIList implements Parcelable { |
| public String nodeName; |
| public String HomeOI; |
| public boolean HomeOIRequired; |
| |
| public HomeOIList(String nn, String h, boolean r) { |
| nodeName = nn; |
| HomeOI = h; |
| HomeOIRequired = r; |
| } |
| |
| public HomeOIList() { |
| } |
| |
| public HomeOIList(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(HomeOI); |
| out.writeInt(HomeOIRequired ? 1 : 0); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| HomeOI = in.readString(); |
| HomeOIRequired = (in.readInt() == 1) ? true : false; |
| } |
| } |
| |
| public static final Parcelable.Creator<HomeOIList> CREATOR = new Parcelable.Creator<HomeOIList>() { |
| public HomeOIList createFromParcel(Parcel in) { |
| return new HomeOIList(in); |
| } |
| |
| public HomeOIList[] newArray(int size) { |
| return new HomeOIList[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/HomeSP/OtherHomePartners |
| **/ |
| public static class OtherHomePartners implements Parcelable { |
| public String nodeName; |
| public String FQDN; |
| |
| public OtherHomePartners(String nn, String f) { |
| nodeName = nn; |
| FQDN = f; |
| } |
| |
| public OtherHomePartners() { |
| } |
| |
| public OtherHomePartners(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(nodeName); |
| out.writeString(FQDN); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| nodeName = in.readString(); |
| FQDN = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<OtherHomePartners> CREATOR = new Parcelable.Creator<OtherHomePartners>() { |
| public OtherHomePartners createFromParcel(Parcel in) { |
| return new OtherHomePartners(in); |
| } |
| |
| public OtherHomePartners[] newArray(int size) { |
| return new OtherHomePartners[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/SubscriptionParameters |
| **/ |
| public static class SubscriptionParameters implements Parcelable { |
| public String CreationDate; |
| public String ExpirationDate; |
| public String TypeOfSubscription; |
| public UsageLimits usageLimits = new UsageLimits(); |
| |
| public SubscriptionParameters() { |
| } |
| |
| public SubscriptionParameters(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(CreationDate); |
| out.writeString(ExpirationDate); |
| out.writeString(TypeOfSubscription); |
| out.writeParcelable(usageLimits, flags); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| CreationDate = in.readString(); |
| ExpirationDate = in.readString(); |
| TypeOfSubscription = in.readString(); |
| usageLimits = in.readParcelable(UsageLimits.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<SubscriptionParameters> CREATOR = new Parcelable.Creator<SubscriptionParameters>() { |
| public SubscriptionParameters createFromParcel(Parcel in) { |
| return new SubscriptionParameters(in); |
| } |
| |
| public SubscriptionParameters[] newArray(int size) { |
| return new SubscriptionParameters[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/SubscriptionParameters/UsageLimits |
| **/ |
| public static class UsageLimits implements Parcelable { |
| public String DataLimit; |
| public String StartDate; |
| public String TimeLimit; |
| public String UsageTimePeriod; |
| |
| public UsageLimits() { |
| } |
| |
| public UsageLimits(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(DataLimit); |
| out.writeString(StartDate); |
| out.writeString(TimeLimit); |
| out.writeString(UsageTimePeriod); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| DataLimit = in.readString(); |
| StartDate = in.readString(); |
| TimeLimit = in.readString(); |
| UsageTimePeriod = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<UsageLimits> CREATOR = new Parcelable.Creator<UsageLimits>() { |
| public UsageLimits createFromParcel(Parcel in) { |
| return new UsageLimits(in); |
| } |
| |
| public UsageLimits[] newArray(int size) { |
| return new UsageLimits[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Credential |
| **/ |
| public static class Credential implements Parcelable { |
| public String CreationDate; |
| public String ExpirationDate; |
| public UsernamePassword usernamePassword = new UsernamePassword(); |
| public DigitalCertificate digitalCertificate = new DigitalCertificate(); |
| public String Realm; |
| public boolean CheckAAAServerCertStatus; |
| public SIM sim = new SIM(); |
| |
| public Credential() { |
| } |
| |
| public Credential(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(CreationDate); |
| out.writeString(ExpirationDate); |
| out.writeParcelable(usernamePassword, flags); |
| out.writeParcelable(digitalCertificate, flags); |
| out.writeString(Realm); |
| out.writeInt(CheckAAAServerCertStatus ? 1 : 0); |
| out.writeParcelable(sim, flags); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| CreationDate = in.readString(); |
| ExpirationDate = in.readString(); |
| usernamePassword = in.readParcelable(UsernamePassword.class.getClassLoader()); |
| digitalCertificate = in.readParcelable(DigitalCertificate.class.getClassLoader()); |
| Realm = in.readString(); |
| CheckAAAServerCertStatus = (in.readInt() == 1) ? true : false; |
| sim = in.readParcelable(SIM.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<Credential> CREATOR = new Parcelable.Creator<Credential>() { |
| public Credential createFromParcel(Parcel in) { |
| return new Credential(in); |
| } |
| |
| public Credential[] newArray(int size) { |
| return new Credential[size]; |
| } |
| }; |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Credential/DigitalCertificate |
| **/ |
| public static class DigitalCertificate implements Parcelable { |
| public String CertificateType; |
| public String CertSHA256Fingerprint; |
| |
| public DigitalCertificate() { |
| } |
| |
| public DigitalCertificate(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(CertificateType); |
| out.writeString(CertSHA256Fingerprint); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| CertificateType = in.readString(); |
| CertSHA256Fingerprint = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<DigitalCertificate> CREATOR = new Parcelable.Creator<DigitalCertificate>() { |
| public DigitalCertificate createFromParcel(Parcel in) { |
| return new DigitalCertificate(in); |
| } |
| |
| public DigitalCertificate[] newArray(int size) { |
| return new DigitalCertificate[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Credential/SIM |
| **/ |
| public static class SIM implements Parcelable { |
| public String IMSI; |
| public String EAPType; |
| |
| public SIM() { |
| } |
| |
| public SIM(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeString(IMSI); |
| out.writeString(EAPType); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| IMSI = in.readString(); |
| EAPType = in.readString(); |
| } |
| } |
| |
| public static final Parcelable.Creator<SIM> CREATOR = new Parcelable.Creator<SIM>() { |
| public SIM createFromParcel(Parcel in) { |
| return new SIM(in); |
| } |
| |
| public SIM[] newArray(int size) { |
| return new SIM[size]; |
| } |
| }; |
| |
| } |
| |
| /** |
| * PerProviderSubscription/<X+>/Extension |
| **/ |
| public static class Extension { |
| public String empty; |
| } |
| |
| public WifiPasspointDmTree() { |
| } |
| |
| public WifiPasspointDmTree(Parcel in) { |
| readFromParcel(in); |
| } |
| |
| public int describeContents() { |
| return 0; |
| } |
| |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeMap(spFqdn); |
| } |
| |
| public void readFromParcel(Parcel in) { |
| if (in == null) { |
| //log here |
| } else { |
| in.readMap(spFqdn, SpFqdn.class.getClassLoader()); |
| } |
| } |
| |
| public static final Parcelable.Creator<WifiPasspointDmTree> CREATOR = new Parcelable.Creator<WifiPasspointDmTree>() { |
| public WifiPasspointDmTree createFromParcel(Parcel in) { |
| return new WifiPasspointDmTree(in); |
| } |
| |
| public WifiPasspointDmTree[] newArray(int size) { |
| return new WifiPasspointDmTree[size]; |
| } |
| }; |
| |
| } |
