resolved conflicts for merge of 4eede890 to jb-mr2-dev
Jake Hamby [Tue, 26 Mar 2013 01:11:03 +0000 (18:11 -0700)]
Change-Id: I7ee1d93d832275ad04d4e6bbae68d22ae86322ac

1  2 
src/java/com/android/internal/telephony/IntRangeManager.java

@@@ -110,18 -110,33 +110,34 @@@ public abstract class IntRangeManager 
           * @param range the new ClientRange to insert
           */
          void insert(ClientRange range) {
 -            int len = clients.size();
 +            int len = mClients.size();
+             int insert = -1;
              for (int i=0; i < len; i++) {
 -                ClientRange nextRange = clients.get(i);
 -                if (range.startId <= nextRange.startId) {
 +                ClientRange nextRange = mClients.get(i);
 +                if (range.mStartId <= nextRange.mStartId) {
                      // ignore duplicate ranges from the same client
                      if (!range.equals(nextRange)) {
+                         // check if same startId, then order by endId
 -                        if (range.startId == nextRange.startId && range.endId > nextRange.endId) {
++                        if (range.mStartId == nextRange.mStartId
++                                && range.mEndId > nextRange.mEndId) {
+                             insert = i + 1;
+                             if (insert < len) {
+                                 // there may be more client following with same startId
+                                 // new [1, 5] existing [1, 2] [1, 4] [1, 7]
+                                 continue;
+                             }
+                             break;
+                         }
 -                        clients.add(i, range);
 +                        mClients.add(i, range);
                      }
                      return;
                  }
              }
+             if (insert != -1 && insert < len) {
 -                clients.add(insert, range);
++                mClients.add(insert, range);
+                 return;
+             }
 -            clients.add(range);    // append to end of list
 +            mClients.add(range);    // append to end of list
          }
      }
  
  
          for (int startIndex = 0; startIndex < len; startIndex++) {
              IntRange range = mRanges.get(startIndex);
-             if (startId < range.mStartId) {
 -            if ((startId) >= range.startId && (endId) <= range.endId) {
++            if ((startId) >= range.mStartId && (endId) <= range.mEndId) {
+                 // exact same range:  new [1, 1] existing [1, 1]
+                 // range already enclosed in existing: new [3, 3], [1,3]
+                 // no radio update necessary.
+                 // duplicate "client" check is done in insert, attempt to insert.
+                 range.insert(new ClientRange(startId, endId, client));
+                 return true;
 -            } else if ((startId - 1) == range.endId) {
++            } else if ((startId - 1) == range.mEndId) {
+                 // new [3, x] existing [1, 2]  OR new [2, 2] existing [1, 1]
+                 // found missing link? check if next range can be joined
+                 int newRangeEndId = endId;
+                 IntRange nextRange = null;
+                 if ((startIndex + 1) < len) {
+                     nextRange = mRanges.get(startIndex + 1);
 -                    if ((nextRange.startId - 1) <= endId) {
++                    if ((nextRange.mStartId - 1) <= endId) {
+                         // new [3, x] existing [1, 2] [5, 7] OR  new [2 , 2] existing [1, 1] [3, 5]
 -                        if (endId <= nextRange.endId) {
++                        if (endId <= nextRange.mEndId) {
+                             // new [3, 6] existing [1, 2] [5, 7]
 -                            newRangeEndId = nextRange.startId - 1; // need to enable [3, 4]
++                            newRangeEndId = nextRange.mStartId - 1; // need to enable [3, 4]
+                         }
+                     } else {
+                         // mark nextRange to be joined as null.
+                         nextRange = null;
+                     }
+                 }
+                 if (tryAddRanges(startId, newRangeEndId, true)) {
 -                    range.endId = endId;
++                    range.mEndId = endId;
+                     range.insert(new ClientRange(startId, endId, client));
+                     // found missing link? check if next range can be joined
+                     if (nextRange != null) {
 -                        if (range.endId < nextRange.endId) {
++                        if (range.mEndId < nextRange.mEndId) {
+                             // new [3, 6] existing [1, 2] [5, 10]
 -                            range.endId = nextRange.endId;
++                            range.mEndId = nextRange.mEndId;
+                         }
 -                        range.clients.addAll(nextRange.clients);
++                        range.mClients.addAll(nextRange.mClients);
+                         mRanges.remove(nextRange);
+                     }
+                     return true;
+                 } else {
+                     return false;   // failed to update radio
+                 }
 -            } else if (startId < range.startId) {
++            } else if (startId < range.mStartId) {
+                 // new [1, x] , existing [5, y]
                  // test if new range completely precedes this range
                  // note that [1, 4] and [5, 6] coalesce to [1, 6]
 -                if ((endId + 1) < range.startId) {
 +                if ((endId + 1) < range.mStartId) {
+                     // new [1, 3] existing [5, 6] non contiguous case
                      // insert new int range before previous first range
-                     if (tryAddSingleRange(startId, endId, true)) {
+                     if (tryAddRanges(startId, endId, true)) {
                          mRanges.add(startIndex, new IntRange(startId, endId, client));
                          return true;
                      } else {
                          return false;   // failed to update radio
                      }
 -                } else if (endId <= range.endId) {
 +                } else if (endId <= range.mEndId) {
+                     // new [1, 4] existing [5, 6]  or  new [1, 1] existing [2, 2]
                      // extend the start of this range
-                     if (tryAddSingleRange(startId, range.mStartId - 1, true)) {
 -                    if (tryAddRanges(startId, range.startId - 1, true)) {
 -                        range.startId = startId;
 -                        range.clients.add(0, new ClientRange(startId, endId, client));
++                    if (tryAddRanges(startId, range.mStartId - 1, true)) {
 +                        range.mStartId = startId;
 +                        range.mClients.add(0, new ClientRange(startId, endId, client));
                          return true;
                      } else {
                          return false;   // failed to update radio
                      // find last range that can coalesce into the new combined range
                      for (int endIndex = startIndex+1; endIndex < len; endIndex++) {
                          IntRange endRange = mRanges.get(endIndex);
 -                        if ((endId + 1) < endRange.startId) {
 +                        if ((endId + 1) < endRange.mStartId) {
+                             // new [1, 10] existing [2, 3] [14, 15]
                              // try to add entire new range
-                             if (tryAddSingleRange(startId, endId, true)) {
+                             if (tryAddRanges(startId, endId, true)) {
 -                                range.startId = startId;
 -                                range.endId = endId;
 +                                range.mStartId = startId;
 +                                range.mEndId = endId;
                                  // insert new ClientRange before existing ranges
 -                                range.clients.add(0, new ClientRange(startId, endId, client));
 +                                range.mClients.add(0, new ClientRange(startId, endId, client));
                                  // coalesce range with following ranges up to endIndex-1
                                  // remove each range after adding its elements, so the index
                                  // of the next range to join is always startIndex+1.
                                  // about the number of loop iterations, not the value of i.
                                  int joinIndex = startIndex + 1;
                                  for (int i = joinIndex; i < endIndex; i++) {
+                                     // new [1, 10] existing [2, 3] [5, 6] [14, 15]
                                      IntRange joinRange = mRanges.get(joinIndex);
 -                                    range.clients.addAll(joinRange.clients);
 +                                    range.mClients.addAll(joinRange.mClients);
                                      mRanges.remove(joinRange);
                                  }
                                  return true;
                              } else {
                                  return false;   // failed to update radio
                              }
 -                        } else if (endId <= endRange.endId) {
 +                        } else if (endId <= endRange.mEndId) {
+                             // new [1, 10] existing [2, 3] [5, 15]
                              // add range from start id to start of last overlapping range,
                              // values from endRange.startId to endId are already enabled
-                             if (tryAddSingleRange(startId, endRange.mStartId - 1, true)) {
 -                            if (tryAddRanges(startId, endRange.startId - 1, true)) {
 -                                range.startId = startId;
 -                                range.endId = endRange.endId;
++                            if (tryAddRanges(startId, endRange.mStartId - 1, true)) {
 +                                range.mStartId = startId;
 +                                range.mEndId = endRange.mEndId;
                                  // insert new ClientRange before existing ranges
 -                                range.clients.add(0, new ClientRange(startId, endId, client));
 +                                range.mClients.add(0, new ClientRange(startId, endId, client));
                                  // coalesce range with following ranges up to endIndex
                                  // remove each range after adding its elements, so the index
                                  // of the next range to join is always startIndex+1.
                          }
                      }
  
+                     // new [1, 10] existing [2, 3]
                      // endId extends past all existing IntRanges: combine them all together
-                     if (tryAddSingleRange(startId, endId, true)) {
+                     if (tryAddRanges(startId, endId, true)) {
 -                        range.startId = startId;
 -                        range.endId = endId;
 +                        range.mStartId = startId;
 +                        range.mEndId = endId;
                          // insert new ClientRange before existing ranges
 -                        range.clients.add(0, new ClientRange(startId, endId, client));
 +                        range.mClients.add(0, new ClientRange(startId, endId, client));
                          // coalesce range with following ranges up to len-1
                          // remove each range after adding its elements, so the index
                          // of the next range to join is always startIndex+1.
                          // about the number of loop iterations, not the value of i.
                          int joinIndex = startIndex + 1;
                          for (int i = joinIndex; i < len; i++) {
+                             // new [1, 10] existing [2, 3] [5, 6]
                              IntRange joinRange = mRanges.get(joinIndex);
 -                            range.clients.addAll(joinRange.clients);
 +                            range.mClients.addAll(joinRange.mClients);
                              mRanges.remove(joinRange);
                          }
                          return true;
                          return false;   // failed to update radio
                      }
                  }
 -            } else if ((startId + 1) <= range.endId) {
 +            } else if ((startId + 1) <= range.mEndId) {
+                 // new [2, x] existing [1, 4]
 -                if (endId <= range.endId) {
 +                if (endId <= range.mEndId) {
+                     // new [2, 3] existing [1, 4]
                      // completely contained in existing range; no radio changes
                      range.insert(new ClientRange(startId, endId, client));
                      return true;
                      }
                      // no adjacent IntRanges to combine
                      if (endIndex == startIndex) {
+                         // new [2, 5] existing [1, 4]
                          // add range from range.endId+1 to endId,
                          // values from startId to range.endId are already enabled
-                         if (tryAddSingleRange(range.mEndId + 1, endId, true)) {
 -                        if (tryAddRanges(range.endId + 1, endId, true)) {
 -                            range.endId = endId;
++                        if (tryAddRanges(range.mEndId + 1, endId, true)) {
 +                            range.mEndId = endId;
                              range.insert(new ClientRange(startId, endId, client));
                              return true;
                          } else {
                      // if endId > endRange.endId, then enable range from range.endId+1 to endId,
                      // else enable range from range.endId+1 to endRange.startId-1, because
                      // values from endRange.startId to endId have already been added.
 -                    int newRangeEndId = (endId <= endRange.endId) ? endRange.startId - 1 : endId;
 +                    int newRangeEndId = (endId <= endRange.mEndId) ? endRange.mStartId - 1 : endId;
-                     if (tryAddSingleRange(range.mEndId + 1, newRangeEndId, true)) {
-                         range.mEndId = endId;
+                     // new [2, 10] existing [1, 4] [7, 8] OR
+                     // new [2, 10] existing [1, 4] [7, 15]
 -                    if (tryAddRanges(range.endId + 1, newRangeEndId, true)) {
 -                        newRangeEndId = (endId <= endRange.endId) ? endRange.endId : endId;
 -                        range.endId = newRangeEndId;
++                    if (tryAddRanges(range.mEndId + 1, newRangeEndId, true)) {
++                        newRangeEndId = (endId <= endRange.mEndId) ? endRange.mEndId : endId;
++                        range.mEndId = newRangeEndId;
                          // insert new ClientRange in place
                          range.insert(new ClientRange(startId, endId, client));
-                         // coalesce range with following ranges up to endIndex-1
+                         // coalesce range with following ranges up to endIndex
                          // remove each range after adding its elements, so the index
                          // of the next range to join is always startIndex+1 (joinIndex).
                          // i is the index if no elements had been removed: we only care
                          // about the number of loop iterations, not the value of i.
                          int joinIndex = startIndex + 1;
-                         for (int i = joinIndex; i < endIndex; i++) {
+                         for (int i = joinIndex; i <= endIndex; i++) {
                              IntRange joinRange = mRanges.get(joinIndex);
 -                            range.clients.addAll(joinRange.clients);
 +                            range.mClients.addAll(joinRange.mClients);
                              mRanges.remove(joinRange);
                          }
                          return true;
                  int crLength = clients.size();
                  if (crLength == 1) {
                      ClientRange cr = clients.get(0);
 -                    if (cr.startId == startId && cr.endId == endId && cr.client.equals(client)) {
 +                    if (cr.mStartId == startId && cr.mEndId == endId && cr.mClient.equals(client)) {
-                         // disable range in radio then remove the entire IntRange
-                         if (tryAddSingleRange(startId, endId, false)) {
-                             mRanges.remove(i);
+                         // mRange contains only what's enabled.
+                         // remove the range from mRange then update the radio
+                         mRanges.remove(i);
+                         if (updateRanges()) {
                              return true;
                          } else {
-                             return false;   // failed to update radio
+                             // failed to update radio.  insert back the range
+                             mRanges.add(i, range);
+                             return false;
                          }
                      } else {
                          return false;   // not found
                  int largestEndId = Integer.MIN_VALUE;  // largest end identifier found
                  boolean updateStarted = false;
  
+                 // crlength >= 2
                  for (int crIndex=0; crIndex < crLength; crIndex++) {
                      ClientRange cr = clients.get(crIndex);
 -                    if (cr.startId == startId && cr.endId == endId && cr.client.equals(client)) {
 +                    if (cr.mStartId == startId && cr.mEndId == endId && cr.mClient.equals(client)) {
                          // found the ClientRange to remove, check if it's the last in the list
                          if (crIndex == crLength - 1) {
 -                            if (range.endId == largestEndId) {
 +                            if (range.mEndId == largestEndId) {
+                                 // remove [2, 5] from [1, 7] [2, 5]
                                  // no channels to remove from radio; return success
                                  clients.remove(crIndex);
                                  return true;
                              } else {
                                  // disable the channels at the end and lower the end id
-                                 if (tryAddSingleRange(largestEndId + 1, range.mEndId, false)) {
-                                     clients.remove(crIndex);
-                                     range.mEndId = largestEndId;
+                                 clients.remove(crIndex);
 -                                range.endId = largestEndId;
++                                range.mEndId = largestEndId;
+                                 if (updateRanges()) {
                                      return true;
                                  } else {
+                                     clients.add(crIndex, cr);
 -                                    range.endId = cr.endId;
++                                    range.mEndId = cr.mEndId;
                                      return false;
                                  }
                              }
                              // removing the first ClientRange, so we may need to increase
                              // the start id of the IntRange.
                              // We know there are at least two ClientRanges in the list,
 -                            // because check for just one ClientRangees case is already handled
++                            // because check for just one ClientRanges case is already handled
                              // so clients.get(1) should always succeed.
 -                            int nextStartId = clients.get(1).startId;
 -                            if (nextStartId != range.startId) {
 +                            int nextStartId = clients.get(1).mStartId;
 +                            if (nextStartId != range.mStartId) {
-                                 startUpdate();
                                  updateStarted = true;
-                                 addRange(range.mStartId, nextStartId - 1, false);
 -                                rangeCopy.startId = nextStartId;
 +                                rangeCopy.mStartId = nextStartId;
                              }
                              // init largestEndId
 -                            largestEndId = clients.get(1).endId;
 +                            largestEndId = clients.get(1).mEndId;
                          }
  
                          // go through remaining ClientRanges, creating new IntRanges when
                          IntRange currentRange = rangeCopy;
                          for (int nextIndex = crIndex + 1; nextIndex < crLength; nextIndex++) {
                              ClientRange nextCr = clients.get(nextIndex);
 -                            if (nextCr.startId > largestEndId + 1) {
 +                            if (nextCr.mStartId > largestEndId + 1) {
-                                 if (!updateStarted) {
-                                     startUpdate();
-                                     updateStarted = true;
-                                 }
-                                 addRange(largestEndId + 1, nextCr.mStartId - 1, false);
+                                 updateStarted = true;
 -                                currentRange.endId = largestEndId;
 +                                currentRange.mEndId = largestEndId;
                                  newRanges.add(currentRange);
                                  currentRange = new IntRange(nextCr);
                              } else {
 -                                if (currentRange.endId < nextCr.endId) {
 -                                    currentRange.endId = nextCr.endId;
++                                if (currentRange.mEndId < nextCr.mEndId) {
++                                    currentRange.mEndId = nextCr.mEndId;
+                                 }
 -                                currentRange.clients.add(nextCr);
 +                                currentRange.mClients.add(nextCr);
                              }
 -                            if (nextCr.endId > largestEndId) {
 -                                largestEndId = nextCr.endId;
 +                            if (nextCr.mEndId > largestEndId) {
 +                                largestEndId = nextCr.mEndId;
                              }
                          }
  
                          // remove any channels between largestEndId and endId
                          if (largestEndId < endId) {
-                             if (!updateStarted) {
-                                 startUpdate();
-                                 updateStarted = true;
-                             }
-                             addRange(largestEndId + 1, endId, false);
+                             updateStarted = true;
 -                            currentRange.endId = largestEndId;
 +                            currentRange.mEndId = largestEndId;
                          }
                          newRanges.add(currentRange);
  
      }
  
      /**
+      * Called when attempting to add a single range of message identifiers
+      * Populate all ranges of message identifiers.
+      */
+     private void populateAllRanges() {
+         Iterator<IntRange> itr = mRanges.iterator();
+         // Populate all ranges from mRanges
+         while (itr.hasNext()) {
+             IntRange currRange = (IntRange) itr.next();
 -            addRange(currRange.startId, currRange.endId, true);
++            addRange(currRange.mStartId, currRange.mEndId, true);
+         }
+     }
+     /**
+      * Called when attempting to add a single range of message identifiers
+      * Populate all ranges of message identifiers using clients' ranges.
+      */
+     private void populateAllClientRanges() {
+         int len = mRanges.size();
+         for (int i = 0; i < len; i++) {
+             IntRange range = mRanges.get(i);
 -            int clientLen = range.clients.size();
++            int clientLen = range.mClients.size();
+             for (int j=0; j < clientLen; j++) {
 -                ClientRange nextRange = range.clients.get(j);
 -                addRange(nextRange.startId, nextRange.endId, true);
++                ClientRange nextRange = range.mClients.get(j);
++                addRange(nextRange.mStartId, nextRange.mEndId, true);
+             }
+         }
+     }
+     /**
       * Called when the list of enabled ranges has changed. This will be
       * followed by zero or more calls to {@link #addRange} followed by
       * a call to {@link #finishUpdate}.