1 /*
2  * Copyright (C) 2017 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 
18 package com.android.internal.util;
19 
20 import android.annotation.Nullable;
21 import android.text.TextUtils;
22 
23 import java.nio.ByteBuffer;
24 import java.util.Arrays;
25 import java.util.Objects;
26 import java.util.UUID;
27 import java.util.function.IntFunction;
28 
29 /**
30  * A utility class for handling unsigned integers and unsigned arithmetics, as well as syntactic
31  * sugar methods for {@link ByteBuffer}. Useful for networking and packet manipulations.
32  * {@hide}
33  */
34 @android.ravenwood.annotation.RavenwoodKeepWholeClass
35 public final class BitUtils {
BitUtils()36     private BitUtils() {}
37 
maskedEquals(long a, long b, long mask)38     public static boolean maskedEquals(long a, long b, long mask) {
39         return (a & mask) == (b & mask);
40     }
41 
maskedEquals(byte a, byte b, byte mask)42     public static boolean maskedEquals(byte a, byte b, byte mask) {
43         return (a & mask) == (b & mask);
44     }
45 
maskedEquals(byte[] a, byte[] b, @Nullable byte[] mask)46     public static boolean maskedEquals(byte[] a, byte[] b, @Nullable byte[] mask) {
47         if (a == null || b == null) return a == b;
48         Preconditions.checkArgument(a.length == b.length, "Inputs must be of same size");
49         if (mask == null) return Arrays.equals(a, b);
50         Preconditions.checkArgument(a.length == mask.length, "Mask must be of same size as inputs");
51         for (int i = 0; i < mask.length; i++) {
52             if (!maskedEquals(a[i], b[i], mask[i])) return false;
53         }
54         return true;
55     }
56 
maskedEquals(UUID a, UUID b, @Nullable UUID mask)57     public static boolean maskedEquals(UUID a, UUID b, @Nullable UUID mask) {
58         if (mask == null) {
59             return Objects.equals(a, b);
60         }
61         return maskedEquals(a.getLeastSignificantBits(), b.getLeastSignificantBits(),
62                     mask.getLeastSignificantBits())
63                 && maskedEquals(a.getMostSignificantBits(), b.getMostSignificantBits(),
64                     mask.getMostSignificantBits());
65     }
66 
unpackBits(long val)67     public static int[] unpackBits(long val) {
68         int size = Long.bitCount(val);
69         int[] result = new int[size];
70         int index = 0;
71         int bitPos = 0;
72         while (val != 0) {
73             if ((val & 1) == 1) result[index++] = bitPos;
74             val = val >>> 1;
75             bitPos++;
76         }
77         return result;
78     }
79 
packBits(int[] bits)80     public static long packBits(int[] bits) {
81         long packed = 0;
82         for (int b : bits) {
83             packed |= (1L << b);
84         }
85         return packed;
86     }
87 
uint8(byte b)88     public static int uint8(byte b) {
89         return b & 0xff;
90     }
91 
uint16(short s)92     public static int uint16(short s) {
93         return s & 0xffff;
94     }
95 
uint16(byte hi, byte lo)96     public static int uint16(byte hi, byte lo) {
97         return ((hi & 0xff) << 8) | (lo & 0xff);
98     }
99 
uint32(int i)100     public static long uint32(int i) {
101         return i & 0xffffffffL;
102     }
103 
bytesToBEInt(byte[] bytes)104     public static int bytesToBEInt(byte[] bytes) {
105         return (uint8(bytes[0]) << 24)
106                 + (uint8(bytes[1]) << 16)
107                 + (uint8(bytes[2]) << 8)
108                 + (uint8(bytes[3]));
109     }
110 
bytesToLEInt(byte[] bytes)111     public static int bytesToLEInt(byte[] bytes) {
112         return Integer.reverseBytes(bytesToBEInt(bytes));
113     }
114 
getUint8(ByteBuffer buffer, int position)115     public static int getUint8(ByteBuffer buffer, int position) {
116         return uint8(buffer.get(position));
117     }
118 
getUint16(ByteBuffer buffer, int position)119     public static int getUint16(ByteBuffer buffer, int position) {
120         return uint16(buffer.getShort(position));
121     }
122 
getUint32(ByteBuffer buffer, int position)123     public static long getUint32(ByteBuffer buffer, int position) {
124         return uint32(buffer.getInt(position));
125     }
126 
put(ByteBuffer buffer, int position, byte[] bytes)127     public static void put(ByteBuffer buffer, int position, byte[] bytes) {
128         final int original = buffer.position();
129         buffer.position(position);
130         buffer.put(bytes);
131         buffer.position(original);
132     }
133 
isBitSet(long flags, int bitIndex)134     public static boolean isBitSet(long flags, int bitIndex) {
135         return (flags & bitAt(bitIndex)) != 0;
136     }
137 
bitAt(int bitIndex)138     public static long bitAt(int bitIndex) {
139         return 1L << bitIndex;
140     }
141 
flagsToString(int flags, IntFunction<String> getFlagName)142     public static String flagsToString(int flags, IntFunction<String> getFlagName) {
143         StringBuilder builder = new StringBuilder();
144         int count = 0;
145         while (flags != 0) {
146             final int flag = 1 << Integer.numberOfTrailingZeros(flags);
147             flags &= ~flag;
148             if (count > 0) builder.append(", ");
149             builder.append(getFlagName.apply(flag));
150             count++;
151         }
152         TextUtils.wrap(builder, "[", "]");
153         return builder.toString();
154     }
155 
156     /**
157      * Converts long to byte array
158      */
toBytes(long l)159     public static byte[] toBytes(long l) {
160         return ByteBuffer.allocate(8).putLong(l).array();
161     }
162 
163     /**
164      * 0b01000 -> 0b01111
165      */
flagsUpTo(int lastFlag)166     public static int flagsUpTo(int lastFlag) {
167         return lastFlag <= 0 ? 0 : lastFlag | flagsUpTo(lastFlag >> 1);
168     }
169 
170     /**
171      * 0b00010, 0b01000 -> 0b01110
172      */
flagsWithin(int firstFlag, int lastFlag)173     public static int flagsWithin(int firstFlag, int lastFlag) {
174         return (flagsUpTo(lastFlag) & ~flagsUpTo(firstFlag)) | firstFlag;
175     }
176 }
177