下面列出了android.util.SparseArray#keyAt ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public int selectFocus(Detector.Detections<Document> detections) {
SparseArray<Document> detectedItems;
if((detectedItems = detections.getDetectedItems()).size() == 0) {
throw new IllegalArgumentException("No documents for selectFocus.");
} else {
int itemKey = detectedItems.keyAt(0);
int itemArea = detectedItems.valueAt(0).getMaxArea();
for(int index = 1; index < detectedItems.size(); ++index) {
int itemKey2 = detectedItems.keyAt(index);
int itemArea2;
if((itemArea2 = detectedItems.valueAt(index).getMaxArea()) > itemArea) {
itemKey = itemKey2;
itemArea = itemArea2;
}
}
return itemKey;
}
}
private TrackInfo[] getInbandTrackInfo(String encoding) {
if (mInbandTracks == null) {
SparseArray<byte[]> trackSparse = new SparseArray<byte[]>();
if (!native_getTrackInfo(trackSparse)) {
return null;
}
int size = trackSparse.size();
mInbandTracks = new TrackInfo[size];
for (int i = 0; i < size; i++) {
SparseArray<app.dttv.dttvlib.MediaFormat> sparseArray = parseTrackInfo(trackSparse.valueAt(i), encoding);
TrackInfo trackInfo = new TrackInfo(trackSparse.keyAt(i), sparseArray);
mInbandTracks[i] = trackInfo;
}
}
return mInbandTracks;
}
@VisibleForTesting
static void findAllUnrestrictedPendingBackgroundAlarmsLockedInner(
SparseArray<ArrayList<Alarm>> pendingAlarms, ArrayList<Alarm> unrestrictedAlarms,
Predicate<Alarm> isBackgroundRestricted) {
for (int uidIndex = pendingAlarms.size() - 1; uidIndex >= 0; uidIndex--) {
final int uid = pendingAlarms.keyAt(uidIndex);
final ArrayList<Alarm> alarmsForUid = pendingAlarms.valueAt(uidIndex);
for (int alarmIndex = alarmsForUid.size() - 1; alarmIndex >= 0; alarmIndex--) {
final Alarm alarm = alarmsForUid.get(alarmIndex);
if (isBackgroundRestricted.test(alarm)) {
continue;
}
unrestrictedAlarms.add(alarm);
alarmsForUid.remove(alarmIndex);
}
if (alarmsForUid.size() == 0) {
pendingAlarms.removeAt(uidIndex);
}
}
}
static Bundle saveViewHierarchy(@NonNull View view) {
Bundle bundle = new Bundle();
SparseArray<Parcelable> savedViewHierarchy = new SparseArray<>();
view.saveHierarchyState(savedViewHierarchy);
int count = savedViewHierarchy.size();
for(int i=0; i<count; ++i) {
int key = savedViewHierarchy.keyAt(i);
Parcelable parcelable = savedViewHierarchy.get(key);
String bundleKey = "" + key;
bundle.putParcelable(bundleKey, parcelable);
}
return bundle;
}
static View retrieveFromScrap(SparseArray<View> scrapViews, int position) {
int size = scrapViews.size();
if (size > 0) {
// See if we still have a view for this position.
for (int i = 0; i < size; i++) {
int fromPosition = scrapViews.keyAt(i);
View view = scrapViews.get(fromPosition);
if (fromPosition == position) {
scrapViews.remove(fromPosition);
return view;
}
}
int index = size - 1;
View r = scrapViews.valueAt(index);
scrapViews.remove(scrapViews.keyAt(index));
return r;
} else {
return null;
}
}
private void refreshCores(SparseArray<SwitchView> array, int[] freqs) {
for (int i = 0; i < array.size(); i++) {
SwitchView switchView = array.valueAt(i);
if (switchView != null) {
final int core = array.keyAt(i);
int freq = freqs[core];
String freqText = freq == 0 ? getString(R.string.offline) : (freq / 1000)
+ getString(R.string.mhz);
switchView.clearOnSwitchListener();
switchView.setChecked(freq != 0);
switchView.setSummary(getString(R.string.core, core + 1) + " - " + freqText);
switchView.addOnSwitchListener((switchView1, isChecked) -> {
if (core == 0) {
Utils.toast(R.string.no_offline_core, getActivity());
} else {
mCPUFreq.onlineCpu(core, isChecked, true, getActivity());
}
});
}
}
}
private TrackInfo[] getInbandTrackInfo(String encoding) {
if (mInbandTracks == null) {
SparseArray<byte[]> trackSparse = new SparseArray<byte[]>();
if (!native_getTrackInfo(trackSparse)) {
return null;
}
int size = trackSparse.size();
mInbandTracks = new TrackInfo[size];
for (int i = 0; i < size; i++) {
SparseArray<MediaFormat> sparseArray = parseTrackInfo(trackSparse.valueAt(i), encoding);
TrackInfo trackInfo = new TrackInfo(trackSparse.keyAt(i), sparseArray);
mInbandTracks[i] = trackInfo;
}
}
return mInbandTracks;
}
/**
* Returns the merged change log.
*
* @param full
* If this is {@code true} the full change log is returned. Otherwise only changes for
* versions newer than the last version are returned.
*
* @return A sorted {@code List} containing {@link ReleaseItem}s representing the (partial)
* change log.
*
* @see #getChangeLogComparator()
*/
public List<ReleaseItem> getChangeLog(boolean full) {
SparseArray<ReleaseItem> masterChangelog = getMasterChangeLog(full);
SparseArray<ReleaseItem> changelog = getLocalizedChangeLog(full);
List<ReleaseItem> mergedChangeLog =
new ArrayList<ReleaseItem>(masterChangelog.size());
for (int i = 0, len = masterChangelog.size(); i < len; i++) {
int key = masterChangelog.keyAt(i);
// Use release information from localized change log and fall back to the master file
// if necessary.
ReleaseItem release = changelog.get(key, masterChangelog.get(key));
mergedChangeLog.add(release);
}
Collections.sort(mergedChangeLog, getChangeLogComparator());
return mergedChangeLog;
}
private void initData(){
SparseArray<List<ConnInfo>> uid2Conns = TrafficMgr.getInstance().getConnsCategoryByUid();
if(uid2Conns != null){
for(int i=0;i<uid2Conns.size();i++){
int uid = uid2Conns.keyAt(i);
List<ConnInfo> conns = uid2Conns.get(uid);
AppConnInfo appConn = new AppConnInfo();
appConn.uid = uid;
appConn.connNum = TrafficMgr.getInstance().getConnNum(uid);
if(conns != null && !conns.isEmpty()){
for(ConnInfo conn:conns){
appConn.accept += conn.accept;
appConn.back += conn.back;
appConn.sent += conn.sent;
appConn.recv += conn.recv;
if(conn.alive){
++appConn.alive;
}
}
}
mUID2AppInfo.put(uid, appConn);
getData().add(uid);
}
}
}
@SuppressWarnings("unchecked")
protected void bind(final ViewHolder holder, final Object item, boolean isSelected,
final ImageLoader imageLoader,
final View.OnClickListener onMessageClickListener,
final View.OnLongClickListener onMessageLongClickListener,
final DateFormatter.Formatter dateHeadersFormatter,
final SparseArray<MessagesListAdapter.OnMessageViewClickListener> clickListenersArray) {
if (item instanceof IMessage) {
((MessageHolders.BaseMessageViewHolder) holder).isSelected = isSelected;
((MessageHolders.BaseMessageViewHolder) holder).imageLoader = imageLoader;
holder.itemView.setOnLongClickListener(onMessageLongClickListener);
holder.itemView.setOnClickListener(onMessageClickListener);
for (int i = 0; i < clickListenersArray.size(); i++) {
final int key = clickListenersArray.keyAt(i);
final View view = holder.itemView.findViewById(key);
if (view != null) {
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
clickListenersArray.get(key).onMessageViewClick(view, (IMessage) item);
}
});
}
}
} else if (item instanceof Date) {
((MessageHolders.DefaultDateHeaderViewHolder) holder).dateHeadersFormatter = dateHeadersFormatter;
}
holder.onBind(item);
}
/**
* Returns an id which isn't used in the given array. If the maximum id in the array is smaller
* than {@link java.lang.Integer#MAX_VALUE} it just returns the next bigger integer. Otherwise it
* returns the smallest unused non-negative integer.
*/
//@VisibleForTesting
public static int getNewId(SparseArray<String> idToKey) {
int size = idToKey.size();
int id = size == 0 ? 0 : (idToKey.keyAt(size - 1) + 1);
if (id < 0) { // In case if we pass max int value.
// TODO optimization: defragmentation or binary search?
for (id = 0; id < size; id++) {
if (id != idToKey.keyAt(id)) {
break;
}
}
}
return id;
}
public boolean isExportingFeature(Class<? extends Feature> featureClass) {
SparseArray<Class<? extends Feature>> decoder = Manager.getNodeFeatures(
getTypeId());
long advertiseBitMask = getAdvertiseBitMask();
for (int i = 0 ; i< decoder.size(); i++){
if(featureClass == decoder.valueAt(i)){
long mask = decoder.keyAt(i);
if((advertiseBitMask & mask) != 0)
return true;
}
}
return false;
}
@Override
public String toString() {
final ReentrantLock lock = this.mLock;
lock.lock();
try {
final StringBuilder stringBuilder = new StringBuilder();
if (this.mQueues.size() > 0) {
final SparseArray<IList<T>> queues = this.mQueues;
final SparseIntArray queueCapacities = this.mQueueCapacities;
stringBuilder.append(" [\n");
final int queueCount = queues.size();
for (int i = 0; i < queueCount; i++) {
final int priority = queues.keyAt(i);
final IList<T> queue = queues.valueAt(i);
final int queueCapacity = queueCapacities.valueAt(i);
final int queueSize = queue.size();
stringBuilder.append("\tPriority: ").append(priority).append(" (Capacity: ").append(queueSize).append('/').append(queueCapacity).append("): ");
stringBuilder.append(queue.toString());
if (i < (queueCount - 1)) {
stringBuilder.append(',');
}
stringBuilder.append('\n');
}
stringBuilder.append(']');
}
return stringBuilder.toString();
} finally {
lock.unlock();
}
}
/**
* We only accept the barcode inside the scanner square. Note that the return dimensions for the
* barcodes is based on the camera's coordinates, so we must convert it to the canvas' coordinate
* for comparing with the scanner square.
*/
@Override
public int selectFocus(Detections<Barcode> detections) {
SparseArray<Barcode> barcodes = detections.getDetectedItems();
for (int i = 0; i < barcodes.size(); ++i) {
int id = barcodes.keyAt(i);
if (!mCentralFilterEnabled
|| BarcodeCentralFilter.barcodeIsInsideScannerSquare(barcodes.valueAt(i))) {
return id;
}
}
return -1;
}
public void clear() {
SparseArray<Object> idToObjectMap;
synchronized (mSync) {
idToObjectMap = mIdToObjectMap;
mObjectToIdMap.clear();
mIdToObjectMap = new SparseArray<Object>();
}
int size = idToObjectMap.size();
for (int i = 0; i < size; ++i) {
int id = idToObjectMap.keyAt(i);
Object object = idToObjectMap.valueAt(i);
onUnmapped(object, id);
}
}
/**
* Remove the duplicates from a list of note fields and tags
*
* @param fields List of fields to remove duplicates from
* @param tags List of tags to remove duplicates from
* @param modelId ID of model to search for duplicates on
*/
public void removeDuplicates(LinkedList<String[]> fields, LinkedList<Set<String>> tags, long modelId) {
// Build a list of the duplicate keys (first fields) and find all notes that have a match with each key
List<String> keys = new ArrayList<>(fields.size());
for (String[] f : fields) {
keys.add(f[0]);
}
SparseArray<List<NoteInfo>> duplicateNotes = getApi().findDuplicateNotes(modelId, keys);
// Do some sanity checks
if (tags.size() != fields.size()) {
throw new IllegalStateException("List of tags must be the same length as the list of fields");
}
if (duplicateNotes.size() == 0 || fields.size() == 0 || tags.size() == 0) {
return;
}
if (duplicateNotes.keyAt(duplicateNotes.size() - 1) >= fields.size()) {
throw new IllegalStateException("The array of duplicates goes outside the bounds of the original lists");
}
// Iterate through the fields and tags LinkedLists, removing those that had a duplicate
ListIterator<String[]> fieldIterator = fields.listIterator();
ListIterator<Set<String>> tagIterator = tags.listIterator();
int listIndex = -1;
for (int i = 0; i < duplicateNotes.size(); i++) {
int duplicateIndex = duplicateNotes.keyAt(i);
while (listIndex < duplicateIndex) {
fieldIterator.next();
tagIterator.next();
listIndex++;
}
fieldIterator.remove();
tagIterator.remove();
}
}
private void updateAchievements() {
int score = Math.max(mPreviousBestScore, mScore);
SparseArray<String> achievementsMap = null;
switch (mGameMode.getDifficulty()) {
case GameDifficulty.Easy:
achievementsMap = GameAchievement.EASYACHIEVEMENTSMAP;
break;
case GameDifficulty.Medium:
achievementsMap = GameAchievement.MEDIUMACHIEVEMENTSMAP;
break;
case GameDifficulty.Hard:
achievementsMap = GameAchievement.HARDACHIEVEMENTSMAP;
break;
case GameDifficulty.Advanced:
achievementsMap = GameAchievement.ADVANCEDACHIEVEMENTSMAP;
break;
}
if (achievementsMap == null) return;
// Remember the highest score associated with achievement unlocked, so we don't unlock it multiple times
SharedPreferences prefs = getSharedPreferences(PREF_NAME, MODE_PRIVATE);
int highestScore = prefs.getInt(HIGHEST_SCORE_FOR_ACHIEVEMENT_PREFIX + mGameMode.getDifficulty(), 0);
for (int i = 0; i < achievementsMap.size(); i++) {
int key = achievementsMap.keyAt(i);
if (key > score) break;
if (key <= highestScore) continue;
if (mGoogleApiClient != null && mGoogleApiClient.isConnected())
Games.Achievements.unlock(mGoogleApiClient, achievementsMap.get(key, ""));
}
if (score > highestScore) {
SharedPreferences.Editor editor = getSharedPreferences(PREF_NAME, MODE_PRIVATE).edit();
editor.putInt(HIGHEST_SCORE_FOR_ACHIEVEMENT_PREFIX + mGameMode.getDifficulty(), score);
editor.apply();
}
}
private void decipherViaWebView(final SparseArray<String> encSignatures)
{
final Context context = weakContext.get();
if (context == null) {
return;
}
final StringBuilder stb = new StringBuilder(decipherFunctions + " function decipher(");
stb.append("){return ");
for (int i = 0; i < encSignatures.size(); i++) {
int key = encSignatures.keyAt(i);
if (i < encSignatures.size() - 1) {
stb.append(decipherFunctionName)
.append("('")
.append(encSignatures.get(key))
.append("')+\"\\n\"+");
} else {
stb.append(decipherFunctionName)
.append("('")
.append(encSignatures.get(key))
.append("')");
}
}
stb.append("};decipher();");
if (LOGGING) Log.e(LOG_TAG, "FunctionDecipher: " + stb);
new Handler(Looper.getMainLooper()).post(() -> new JsEvaluator(context).evaluate(stb.toString(), new JsCallback()
{
@Override
public void onResult(String result)
{
lock.lock();
try {
decipheredSignature = result;
if (LOGGING) Log.e(LOG_TAG, "JsEvaluator-result: " + result);
jsExecuting.signal();
} finally {
lock.unlock();
}
}
@Override
public void onError(String errorMessage)
{
lock.lock();
try {
if (LOGGING)
Log.e(LOG_TAG, errorMessage);
jsExecuting.signal();
} finally {
lock.unlock();
}
}
}));
}
private int extractFeatureMask(Feature f){
SparseArray<Class<? extends Feature>> decoder = Manager.getNodeFeatures(
mAdvertise.getDeviceId());
int index = decoder.indexOfValue(f.getClass());
return decoder.keyAt(index);
}
/**
* Decodes a subtitling packet, returning a list of parsed {@link Cue}s.
*
* @param data The subtitling packet data to decode.
* @param limit The limit in {@code data} at which to stop decoding.
* @return The parsed {@link Cue}s.
*/
public List<Cue> decode(byte[] data, int limit) {
// Parse the input data.
ParsableBitArray dataBitArray = new ParsableBitArray(data, limit);
while (dataBitArray.bitsLeft() >= 48 // sync_byte (8) + segment header (40)
&& dataBitArray.readBits(8) == 0x0F) {
parseSubtitlingSegment(dataBitArray, subtitleService);
}
if (subtitleService.pageComposition == null) {
return Collections.emptyList();
}
// Update the canvas bitmap if necessary.
DisplayDefinition displayDefinition = subtitleService.displayDefinition != null
? subtitleService.displayDefinition : defaultDisplayDefinition;
if (bitmap == null || displayDefinition.width + 1 != bitmap.getWidth()
|| displayDefinition.height + 1 != bitmap.getHeight()) {
bitmap = Bitmap.createBitmap(displayDefinition.width + 1, displayDefinition.height + 1,
Bitmap.Config.ARGB_8888);
canvas.setBitmap(bitmap);
}
// Build the cues.
List<Cue> cues = new ArrayList<>();
SparseArray<PageRegion> pageRegions = subtitleService.pageComposition.regions;
for (int i = 0; i < pageRegions.size(); i++) {
PageRegion pageRegion = pageRegions.valueAt(i);
int regionId = pageRegions.keyAt(i);
RegionComposition regionComposition = subtitleService.regions.get(regionId);
// Clip drawing to the current region and display definition window.
int baseHorizontalAddress = pageRegion.horizontalAddress
+ displayDefinition.horizontalPositionMinimum;
int baseVerticalAddress = pageRegion.verticalAddress
+ displayDefinition.verticalPositionMinimum;
int clipRight = Math.min(baseHorizontalAddress + regionComposition.width,
displayDefinition.horizontalPositionMaximum);
int clipBottom = Math.min(baseVerticalAddress + regionComposition.height,
displayDefinition.verticalPositionMaximum);
canvas.clipRect(baseHorizontalAddress, baseVerticalAddress, clipRight, clipBottom,
Region.Op.REPLACE);
ClutDefinition clutDefinition = subtitleService.cluts.get(regionComposition.clutId);
if (clutDefinition == null) {
clutDefinition = subtitleService.ancillaryCluts.get(regionComposition.clutId);
if (clutDefinition == null) {
clutDefinition = defaultClutDefinition;
}
}
SparseArray<RegionObject> regionObjects = regionComposition.regionObjects;
for (int j = 0; j < regionObjects.size(); j++) {
int objectId = regionObjects.keyAt(j);
RegionObject regionObject = regionObjects.valueAt(j);
ObjectData objectData = subtitleService.objects.get(objectId);
if (objectData == null) {
objectData = subtitleService.ancillaryObjects.get(objectId);
}
if (objectData != null) {
Paint paint = objectData.nonModifyingColorFlag ? null : defaultPaint;
paintPixelDataSubBlocks(objectData, clutDefinition, regionComposition.depth,
baseHorizontalAddress + regionObject.horizontalPosition,
baseVerticalAddress + regionObject.verticalPosition, paint, canvas);
}
}
if (regionComposition.fillFlag) {
int color;
if (regionComposition.depth == REGION_DEPTH_8_BIT) {
color = clutDefinition.clutEntries8Bit[regionComposition.pixelCode8Bit];
} else if (regionComposition.depth == REGION_DEPTH_4_BIT) {
color = clutDefinition.clutEntries4Bit[regionComposition.pixelCode4Bit];
} else {
color = clutDefinition.clutEntries2Bit[regionComposition.pixelCode2Bit];
}
fillRegionPaint.setColor(color);
canvas.drawRect(baseHorizontalAddress, baseVerticalAddress,
baseHorizontalAddress + regionComposition.width,
baseVerticalAddress + regionComposition.height,
fillRegionPaint);
}
Bitmap cueBitmap = Bitmap.createBitmap(bitmap, baseHorizontalAddress, baseVerticalAddress,
regionComposition.width, regionComposition.height);
cues.add(new Cue(cueBitmap, (float) baseHorizontalAddress / displayDefinition.width,
Cue.ANCHOR_TYPE_START, (float) baseVerticalAddress / displayDefinition.height,
Cue.ANCHOR_TYPE_START, (float) regionComposition.width / displayDefinition.width,
(float) regionComposition.height / displayDefinition.height));
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
}
return cues;
}