wifi/passpoint/WifiPasspointDmTree.java

/*
 * 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|-----------+
 *          +---------+
 *
 * For example,
 * ./Wi-Fi/wi-fi.org/PerproviderSubscription/Cred01/Policy/PreferredRoamingPartnerList/Roa01/FQDN_Math
 *
 * 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];
        }
    };

}