core/java/android/net/NetworkPolicy.java

   1 /*
   2  * Copyright (C) 2011 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
  17 package android.net;
  18
  19 import static com.android.internal.util.Preconditions.checkNotNull;
  20
  21 import android.os.Parcel;
  22 import android.os.Parcelable;
  23 import android.util.BackupUtils;
  24
  25 import java.io.ByteArrayOutputStream;
  26 import java.io.DataInputStream;
  27 import java.io.DataOutputStream;
  28 import java.io.IOException;
  29 import java.util.Objects;
  30
  31 /**
  32  * Policy for networks matching a {@link NetworkTemplate}, including usage cycle
  33  * and limits to be enforced.
  34  *
  35  * @hide
  36  */
  37 public class NetworkPolicy implements Parcelable, Comparable<NetworkPolicy> {
  38     /**
  39      * Current Version of the Backup Serializer.
  40      */
  41     private static final int BACKUP_VERSION = 1;
  42
  43     public static final int CYCLE_NONE = -1;
  44     public static final long WARNING_DISABLED = -1;
  45     public static final long LIMIT_DISABLED = -1;
  46     public static final long SNOOZE_NEVER = -1;
  47
  48     public NetworkTemplate template;
  49     public int cycleDay;
  50     public String cycleTimezone;
  51     public long warningBytes;
  52     public long limitBytes;
  53     public long lastWarningSnooze;
  54     public long lastLimitSnooze;
  55     public boolean metered;
  56     public boolean inferred;
  57
  58     private static final long DEFAULT_MTU = 1500;
  59
  60     @Deprecated
  61     public NetworkPolicy(NetworkTemplate template, int cycleDay, String cycleTimezone,
  62             long warningBytes, long limitBytes, boolean metered) {
  63         this(template, cycleDay, cycleTimezone, warningBytes, limitBytes, SNOOZE_NEVER,
  64                 SNOOZE_NEVER, metered, false);
  65     }
  66
  67     public NetworkPolicy(NetworkTemplate template, int cycleDay, String cycleTimezone,
  68             long warningBytes, long limitBytes, long lastWarningSnooze, long lastLimitSnooze,
  69             boolean metered, boolean inferred) {
  70         this.template = checkNotNull(template, "missing NetworkTemplate");
  71         this.cycleDay = cycleDay;
  72         this.cycleTimezone = checkNotNull(cycleTimezone, "missing cycleTimezone");
  73         this.warningBytes = warningBytes;
  74         this.limitBytes = limitBytes;
  75         this.lastWarningSnooze = lastWarningSnooze;
  76         this.lastLimitSnooze = lastLimitSnooze;
  77         this.metered = metered;
  78         this.inferred = inferred;
  79     }
  80
  81     public NetworkPolicy(Parcel in) {
  82         template = in.readParcelable(null);
  83         cycleDay = in.readInt();
  84         cycleTimezone = in.readString();
  85         warningBytes = in.readLong();
  86         limitBytes = in.readLong();
  87         lastWarningSnooze = in.readLong();
  88         lastLimitSnooze = in.readLong();
  89         metered = in.readInt() != 0;
  90         inferred = in.readInt() != 0;
  91     }
  92
  93     @Override
  94     public void writeToParcel(Parcel dest, int flags) {
  95         dest.writeParcelable(template, flags);
  96         dest.writeInt(cycleDay);
  97         dest.writeString(cycleTimezone);
  98         dest.writeLong(warningBytes);
  99         dest.writeLong(limitBytes);
 100         dest.writeLong(lastWarningSnooze);
 101         dest.writeLong(lastLimitSnooze);
 102         dest.writeInt(metered ? 1 : 0);
 103         dest.writeInt(inferred ? 1 : 0);
 104     }
 105
 106     @Override
 107     public int describeContents() {
 108         return 0;
 109     }
 110
 111     /**
 112      * Test if given measurement is over {@link #warningBytes}.
 113      */
 114     public boolean isOverWarning(long totalBytes) {
 115         return warningBytes != WARNING_DISABLED && totalBytes >= warningBytes;
 116     }
 117
 118     /**
 119      * Test if given measurement is near enough to {@link #limitBytes} to be
 120      * considered over-limit.
 121      */
 122     public boolean isOverLimit(long totalBytes) {
 123         // over-estimate, since kernel will trigger limit once first packet
 124         // trips over limit.
 125         totalBytes += 2 * DEFAULT_MTU;
 126         return limitBytes != LIMIT_DISABLED && totalBytes >= limitBytes;
 127     }
 128
 129     /**
 130      * Clear any existing snooze values, setting to {@link #SNOOZE_NEVER}.
 131      */
 132     public void clearSnooze() {
 133         lastWarningSnooze = SNOOZE_NEVER;
 134         lastLimitSnooze = SNOOZE_NEVER;
 135     }
 136
 137     /**
 138      * Test if this policy has a cycle defined, after which usage should reset.
 139      */
 140     public boolean hasCycle() {
 141         return cycleDay != CYCLE_NONE;
 142     }
 143
 144     @Override
 145     public int compareTo(NetworkPolicy another) {
 146         if (another == null || another.limitBytes == LIMIT_DISABLED) {
 147             // other value is missing or disabled; we win
 148             return -1;
 149         }
 150         if (limitBytes == LIMIT_DISABLED || another.limitBytes < limitBytes) {
 151             // we're disabled or other limit is smaller; they win
 152             return 1;
 153         }
 154         return 0;
 155     }
 156
 157     @Override
 158     public int hashCode() {
 159         return Objects.hash(template, cycleDay, cycleTimezone, warningBytes, limitBytes,
 160                 lastWarningSnooze, lastLimitSnooze, metered, inferred);
 161     }
 162
 163     @Override
 164     public boolean equals(Object obj) {
 165         if (obj instanceof NetworkPolicy) {
 166             final NetworkPolicy other = (NetworkPolicy) obj;
 167             return cycleDay == other.cycleDay && warningBytes == other.warningBytes
 168                     && limitBytes == other.limitBytes
 169                     && lastWarningSnooze == other.lastWarningSnooze
 170                     && lastLimitSnooze == other.lastLimitSnooze && metered == other.metered
 171                     && inferred == other.inferred
 172                     && Objects.equals(cycleTimezone, other.cycleTimezone)
 173                     && Objects.equals(template, other.template);
 174         }
 175         return false;
 176     }
 177
 178     @Override
 179     public String toString() {
 180         final StringBuilder builder = new StringBuilder("NetworkPolicy");
 181         builder.append("[").append(template).append("]:");
 182         builder.append(" cycleDay=").append(cycleDay);
 183         builder.append(", cycleTimezone=").append(cycleTimezone);
 184         builder.append(", warningBytes=").append(warningBytes);
 185         builder.append(", limitBytes=").append(limitBytes);
 186         builder.append(", lastWarningSnooze=").append(lastWarningSnooze);
 187         builder.append(", lastLimitSnooze=").append(lastLimitSnooze);
 188         builder.append(", metered=").append(metered);
 189         builder.append(", inferred=").append(inferred);
 190         return builder.toString();
 191     }
 192
 193     public static final Creator<NetworkPolicy> CREATOR = new Creator<NetworkPolicy>() {
 194         @Override
 195         public NetworkPolicy createFromParcel(Parcel in) {
 196             return new NetworkPolicy(in);
 197         }
 198
 199         @Override
 200         public NetworkPolicy[] newArray(int size) {
 201             return new NetworkPolicy[size];
 202         }
 203     };
 204
 205     public byte[] getBytesForBackup() throws IOException {
 206         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 207         DataOutputStream out = new DataOutputStream(baos);
 208
 209         out.writeInt(BACKUP_VERSION);
 210         out.write(template.getBytesForBackup());
 211         out.writeInt(cycleDay);
 212         BackupUtils.writeString(out, cycleTimezone);
 213         out.writeLong(warningBytes);
 214         out.writeLong(limitBytes);
 215         out.writeLong(lastWarningSnooze);
 216         out.writeLong(lastLimitSnooze);
 217         out.writeInt(metered ? 1 : 0);
 218         out.writeInt(inferred ? 1 : 0);
 219         return baos.toByteArray();
 220     }
 221
 222     public static NetworkPolicy getNetworkPolicyFromBackup(DataInputStream in) throws IOException,
 223             BackupUtils.BadVersionException {
 224         int version = in.readInt();
 225         if (version < 1 || version > BACKUP_VERSION) {
 226             throw new BackupUtils.BadVersionException("Unknown Backup Serialization Version");
 227         }
 228
 229         NetworkTemplate template = NetworkTemplate.getNetworkTemplateFromBackup(in);
 230         int cycleDay = in.readInt();
 231         String cycleTimeZone = BackupUtils.readString(in);
 232         long warningBytes = in.readLong();
 233         long limitBytes = in.readLong();
 234         long lastWarningSnooze = in.readLong();
 235         long lastLimitSnooze = in.readLong();
 236         boolean metered = in.readInt() == 1;
 237         boolean inferred = in.readInt() == 1;
 238         return new NetworkPolicy(template, cycleDay, cycleTimeZone, warningBytes, limitBytes,
 239                 lastWarningSnooze, lastLimitSnooze, metered, inferred);
 240     }
 241 }