Java 类android.support.v4.util.ArraySet 实例源码

/**
 * @return a set with the global positions of all selected items
 */
public Set<Integer> getSelections() {
    if (mPositionBasedStateManagement) {
        return mSelections;
    } else {
        Set<Integer> selections = new ArraySet<>();
        Item item;
        for (int i = 0, size = getItemCount(); i < size; i++) {
            item = getItem(i);
            if (item.isSelected()) {
                selections.add(i);
            }
        }
        return selections;
    }
}

public void addOnSharedPreferenceListener(@NonNull OnSharedPreferenceListener listener, @NonNull String... preferenceKeysToListen) {
    ArraySet<String> preferenceKeysListened = mSharedPreferenceListeners.get(listener);

    // One listener can listen to multiple keys changes
    if (preferenceKeysListened == null) {
        preferenceKeysListened = new ArraySet<>();
    }

    for (String key : preferenceKeysToListen) {
        if (key != null) { // varArgs accepts null values...
            preferenceKeysListened.add(key);
        }
    }

    mSharedPreferenceListeners.put(listener, preferenceKeysListened);

    mSharedPreferences.registerOnSharedPreferenceChangeListener(this);
}

/**
 * Stop listening for said preference keys for this listener
 *
 * @param listener                      the listener that stops listening these preference keys
 * @param preferenceKeysToStopListening the keys to unregister from the listener
 */
public void removeOnSharedPreferenceListener(@NonNull OnSharedPreferenceListener listener, @NonNull String... preferenceKeysToStopListening) {
    ArraySet<String> preferenceKeysListened = mSharedPreferenceListeners.get(listener);

    if (preferenceKeysListened != null) {
        for (String key : preferenceKeysToStopListening) {
            if (key != null) {
                preferenceKeysListened.remove(key);
            }
        }

        if (preferenceKeysListened.isEmpty()) {
            mSharedPreferenceListeners.remove(listener);
        }
    }

    if (mSharedPreferenceListeners.isEmpty()) {
        mSharedPreferences.unregisterOnSharedPreferenceChangeListener(this);
    }
}

@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
    for (OnSharedPreferenceListener onSharedPreferenceListener : mSharedPreferenceListeners.keySet()) { // Check if every listener...
        ArraySet<String> preferenceKeysListened = mSharedPreferenceListeners.get(onSharedPreferenceListener);

        if (preferenceKeysListened != null) {
            for (String preferenceKey : preferenceKeysListened) { // ... wants to listen to this key in particular
                if (preferenceKey.equalsIgnoreCase(key)) {
                    onSharedPreferenceListener.onSharedPreferenceChanged(key, sharedPreferences.getAll().get(key));

                    break;
                }
            }
        }
    }
}

public Set<File> getListFile() {
    ArraySet<File> files = new android.support.v4.util.ArraySet<>();
    try {
        SQLiteDatabase sqLiteDatabase = this.getReadableDatabase();
        String query = "SELECT * FROM " + TABLE_FILE_TAB;
        Cursor cursor = sqLiteDatabase.rawQuery(query, null);
        if (cursor.moveToFirst()) {
            do {
                String result = cursor.getString(cursor.getColumnIndex(KEY_FILE_PATH));
                File file = new File(result);
                if (file.isFile())
                    files.add(file);
                else
                    removeFile(result);
            } while (cursor.moveToNext());
        }
        cursor.close();
    } catch (Exception ignored) {

    }
    return files;
}

static Collection<String> checkPurchased(String tag, BigInteger modulus,
                                         List<String> data, List<String> sigs) {
    Collection<String> purchased = new ArraySet<>();
    if (isEmpty(data) || isEmpty(sigs)) {
        return purchased;
    }

    int size = data.size();
    if (size > sigs.size()) {
        size = sigs.size();
    }

    for (int i = 0; i < size; ++i) {
        String datum = data.get(i);
        if (verify(tag, modulus, datum, sigs.get(i))) {
            checkProductId(purchased, tag, datum);
        }
    }
    return purchased;
}

private boolean updateBrevent(boolean brevent) {
    AppsFragment fragment = getFragment();
    Collection<String> selected = new ArraySet<>(fragment.getSelected());
    if (brevent) {
        Iterator it = selected.iterator();
        while (it.hasNext()) {
            if (mImportant.containsKey(it.next())) {
                it.remove();
            }
        }
    }
    if (!selected.isEmpty()) {
        BreventPackages breventPackages = new BreventPackages(brevent, selected);
        breventPackages.undoable = true;
        mHandler.obtainMessage(MESSAGE_BREVENT_REQUEST, breventPackages).sendToTarget();
    }
    clearSelected();
    return false;
}

private void resolveGcmPackages(Set<String> packageNames) {
    // gcm
    List<PackageInfo> packageInfos = getPackageManager().getPackagesHoldingPermissions(
            new String[] {"com.google.android.c2dm.permission.RECEIVE"}, 0);
    if (packageInfos != null) {
        Set<String> gcm = new ArraySet<>();
        for (PackageInfo packageInfo : packageInfos) {
            gcm.add(packageInfo.packageName);
        }
        gcm.retainAll(checkReceiver(new Intent("com.google.android.c2dm.intent.RECEIVE")));
        packageNames.addAll(gcm);
    }
    if (Log.isLoggable(UILog.TAG, Log.DEBUG)) {
        UILog.d("gcm: " + packageNames);
    }
}

public SimpleImageSelector build() {
    SimpleImageSelector simpleImageSelector = new SimpleImageSelector(activityWeakReference);
    simpleImageSelector.needCrop = false;

    if (itemTypes == null) {
        itemTypes = new ArraySet<>();
        itemTypes.add(SelectorItemType.CAMERA);
        itemTypes.add(SelectorItemType.ALBUM);
        itemTypes.add(SelectorItemType.CANCEL);
    }
    simpleImageSelector.itemTypes = itemTypes;

    simpleImageSelector.photoPathCallback = photoPathCallback;

    simpleImageSelector.selectorCallback = selectorCallback;

    return simpleImageSelector.build();
}

public SimpleImageSelector build() {
    SimpleImageSelector simpleImageSelector = new SimpleImageSelector(activityWeakReference);
    simpleImageSelector.needCrop = true;
    simpleImageSelector.cropParameters = parameters;
    simpleImageSelector.croppedImagePathCallback = croppedImagePathCallback;

    if (itemTypes == null) {
        itemTypes = new ArraySet<>();
        itemTypes.add(SelectorItemType.CAMERA);
        itemTypes.add(SelectorItemType.ALBUM);
        itemTypes.add(SelectorItemType.CANCEL);
    }
    simpleImageSelector.itemTypes = itemTypes;

    simpleImageSelector.photoPathCallback = photoPathCallback;

    simpleImageSelector.selectorCallback = selectorCallback;

    return simpleImageSelector.build();
}

private List<NotificationEvent> getSavedEvents(NotificationEvent.Source source) {
    String prefKey = "";
    if (NotificationEvent.fromQms(source)) {
        prefKey = Preferences.Notifications.Data.QMS_EVENTS;
    } else if (NotificationEvent.fromTheme(source)) {
        prefKey = Preferences.Notifications.Data.FAVORITES_EVENTS;
    }

    Set<String> savedEvents = App.get().getPreferences().getStringSet(prefKey, new ArraySet<>());
    StringBuilder responseBuilder = new StringBuilder();
    for (String saved : savedEvents) {
        responseBuilder.append(saved).append('\n');
    }
    String response = responseBuilder.toString();

    if (NotificationEvent.fromQms(source)) {
        return Api.UniversalEvents().getQmsEvents(response);
    } else if (NotificationEvent.fromTheme(source)) {
        return Api.UniversalEvents().getFavoritesEvents(response);
    }
    return new ArrayList<>();
}

private void cleanTimes() {
    Set<String> keys = new ArraySet<>();
    keys.addAll(times.keySet());
    LocalDate date = LocalDate.now();
    int y = date.getYear();
    int m = date.getMonthOfYear();
    List<String> remove = new ArrayList<>();
    for (String key : keys) {
        if (key == null) continue;
        int year = FastParser.parseInt(key.substring(0, 4));
        if (year < y) keys.remove(key);
        else if (year == y) {
            int month = FastParser.parseInt(key.substring(5, 7));
            if (month < m) remove.add(key);
        }
    }
    times.removeAll(remove);

}

/**
 * Returns list of inactive campaign ids based on reporting result
 *
 * @param result response from the server
 * @return set of inactive campaign ids
 */
public static Set<String> getAndUpdateInactiveCampaigns(Context context, GeoReportingResult result) {
    Set<String> inactiveCampaigns = new ArraySet<>();
    if (result == null || result.hasError()) {
        inactiveCampaigns.addAll(GeofencingHelper.getSuspendedCampaignIds(context));
        inactiveCampaigns.addAll(GeofencingHelper.getFinishedCampaignIds(context));
        return inactiveCampaigns;
    }

    GeofencingHelper.addCampaignStatus(context, result.getFinishedCampaignIds(), result.getSuspendedCampaignIds());
    if (result.getFinishedCampaignIds() != null) {
        inactiveCampaigns.addAll(result.getFinishedCampaignIds());
    }
    if (result.getSuspendedCampaignIds() != null) {
        inactiveCampaigns.addAll(result.getSuspendedCampaignIds());
    }
    return inactiveCampaigns;
}

private void cleanTimes() {
    Set<String> keys = new ArraySet<>();
    keys.addAll(times.keySet());
    LocalDate date = LocalDate.now();
    int y = date.getYear();
    int m = date.getMonthOfYear();
    List<String> remove = new ArrayList<>();
    for (String key : keys) {
        if (key == null) continue;
        int year = FastParser.parseInt(key.substring(0, 4));
        if (year < y) keys.remove(key);
        else if (year == y) {
            int month = FastParser.parseInt(key.substring(5, 7));
            if (month < m) remove.add(key);
        }
    }
    times.removeAll(remove);

}

/**
 * internal method to handle the selections if items are added / removed
 *
 * @param positions     the positions map which should be adjusted
 * @param startPosition the global index of the first element modified
 * @param endPosition   the global index up to which the modification changed the indices (should be MAX_INT if we check til the end)
 * @param adjustBy      the value by which the data was shifted
 * @return the adjusted set
 */
public static Set<Integer> adjustPosition(Set<Integer> positions, int startPosition, int endPosition, int adjustBy) {
    Set<Integer> newPositions = new ArraySet<>();

    for (Integer entry : positions) {
        int position = entry;

        //if our current position is not within the bounds to check for we can add it
        if (position < startPosition || position > endPosition) {
            newPositions.add(position);
        } else if (adjustBy > 0) {
            //if we added items and we are within the bounds we can simply add the adjustBy to our entry
            newPositions.add(position + adjustBy);
        } else if (adjustBy < 0) {
            //if we removed items and we are within the bounds we have to check if the item was removed
            //adjustBy is negative in this case
            if (position > startPosition + adjustBy && position <= startPosition) {
                ;//we are within the removed items range we don't add this item anymore
            } else {
                //otherwise we adjust our position
                newPositions.add(position + adjustBy);
            }
        }
    }

    return newPositions;
}

/**
 * @return a set with the items which are currently selected
 */
public Set<Item> getSelectedItems() {
    Set<Integer> selections = getSelections();
    Set<Item> items = new ArraySet<>(selections.size());
    for (Integer position : selections) {
        items.add(getItem(position));
    }
    return items;
}

public FavoriteModel(AppCompatActivity context) {
    this.gson = new Gson();
    this.favoritesType = new TypeToken<ArraySet<FavoriteModelItem>>() {}.getType();
    this.context = context;
    preferences = context.getSharedPreferences(context.getString(R.string.setting_name), MODE_PRIVATE);

    loadFromSettings();
}

private void loadFromSettings() {
    String json = preferences.getString(context.getString(R.string.setting_favorites), "");
    if(json.isEmpty()) {
        favorites = new ArraySet<>();
    } else {
        favorites = gson.fromJson(json, favoritesType);
    }
}

@NonNull
static Collection<Integer> readCollection(Parcel in) {
    int size = in.readInt();
    if (size <= 0) {
        return new ArraySet<>();
    }
    Collection<Integer> collection = new ArraySet<>(size);
    for (int i = 0; i < size; ++i) {
        collection.add(in.readInt());
    }
    return collection;
}

@NonNull
static Collection<String> readCollection(Parcel in) {
    int size = in.readInt();
    if (size <= 0) {
        return new ArraySet<>();
    }
    Collection<String> collection = new ArraySet<>(size);
    for (int i = 0; i < size; ++i) {
        collection.add(in.readString());
    }
    return collection;
}

public AppsItemAdapter(AppsFragment fragment, Handler handler) {
    mFragment = fragment;
    mHandler = handler;
    mAppsInfo = new ArrayList<>();
    mNext = new ArrayList<>();
    mPackages = new ArraySet<>();
    mStatus = fragment.getResources().getStringArray(R.array.process_status);
    mSelected = new ArraySet<>();
    mHandler.sendEmptyMessage(AppsItemHandler.MSG_RETRIEVE_PACKAGES);

    textColorPrimary = ColorStateList.valueOf(getActivity().mTextColorPrimary);
    cardColorBackgroundHighlight = getActivity().mColorControlHighlight;
}

public Collection<String> select(Collection<String> packageNames) {
    Collection<String> changed = new ArraySet<>(mSelected);
    mSelected.clear();
    mSelected.addAll(packageNames);
    mSelected.retainAll(mPackages);
    changed.addAll(mSelected);
    return changed;
}

public Collection<String> selectInverse() {
    Set<String> inverse = new ArraySet<>(mPackages);
    inverse.removeAll(mSelected);
    mSelected.clear();
    mSelected.addAll(inverse);
    return mPackages;
}

private Set<Integer> getUpdatePositions() {
    LinearLayoutManager layoutManager = (LinearLayoutManager) mRecyclerView.getLayoutManager();
    AppsItemAdapter adapter = (AppsItemAdapter) mRecyclerView.getAdapter();
    if (adapter == null || layoutManager == null) {
        return Collections.emptySet();
    }
    int first = layoutManager.findFirstVisibleItemPosition();
    int last = layoutManager.findLastVisibleItemPosition();
    if (first == -1 || last == -1) {
        return Collections.emptySet();
    }
    List<AppsInfo> appsInfoList = adapter.getAppsInfo();
    BreventActivity activity = (BreventActivity) mFragment.getActivity();
    if (appsInfoList.isEmpty() || activity == null) {
        return Collections.emptySet();
    }
    Set<Integer> positions = new ArraySet<>();
    final int now = BreventResponse.now();
    last = Math.min(last, appsInfoList.size() - 1);
    for (int i = first; i <= last; ++i) {
        AppsInfo info = appsInfoList.get(i);
        if (info.isPackage()) {
            positions.add(i);
            int inactive = activity.getInactive(info.packageName);
            AppsItemViewHolder viewHolder = getViewHolder(i);
            if (viewHolder != null) {
                viewHolder.inactive = inactive;
                if (inactive > 0) {
                    long diff = now - inactive;
                    viewHolder.inactiveView.setText(DateUtils.formatElapsedTime(diff));
                } else {
                    viewHolder.inactiveView.setText(null);
                }
            }
        }
    }
    return positions;
}

private Collection<String> getImportant() {
    Set<String> important = new ArraySet<>();
    int size = mImportant.size();
    for (int i = 0; i < size; ++i) {
        important.add(mImportant.keyAt(i));
    }
    size = mFavorite.size();
    for (int i = 0; i < size; ++i) {
        important.add(mFavorite.keyAt(i));
    }
    return important;
}

private void unbreventImportant() {
    Set<String> importantBrevented = new ArraySet<>();
    for (String packageName : mBrevent) {
        if (mImportant.containsKey(packageName)) {
            importantBrevented.add(packageName);
        }
    }
    if (!importantBrevented.isEmpty()) {
        UILog.i("will unbrevent: " + importantBrevented);
        BreventPackages breventPackages = new BreventPackages(false, importantBrevented);
        breventPackages.undoable = false;
        mHandler.obtainMessage(MESSAGE_BREVENT_REQUEST, breventPackages).sendToTarget();
    }
    makePriority();
}

private Collection<String> checkReceiver(Intent intent) {
    Set<String> packageNames = new ArraySet<>();
    List<ResolveInfo> resolveInfos = getPackageManager().queryBroadcastReceivers(intent, 0);
    if (resolveInfos != null) {
        for (ResolveInfo resolveInfo : resolveInfos) {
            packageNames.add(resolveInfo.activityInfo.packageName);
        }
    }
    return packageNames;
}

public Builder from(SelectorItemType... types) {
    itemTypes = new ArraySet<>();

    Collections.addAll(itemTypes, types);

    if (itemTypes.isEmpty()) {
        throw new IllegalStateException("selector item can't be empty");
    }

    if (itemTypes.size() == 1 && itemTypes.contains(SelectorItemType.CANCEL)) {
        throw new IllegalStateException("you can't use cancel only!!!");
    }
    return this;
}

NearDiscoveryImpl(long discoverableTimeout,
                  long discoveryTimeout,
                  long discoverablePingInterval,
                  Listener listener, Looper looper,
                  Context context) {
    mDiscoverableTimeout = discoverableTimeout;
    mDiscoveryTimeout = discoveryTimeout;
    mPingInterval = discoverablePingInterval;
    mListener = listener;
    mListenerLooper = looper;
    mContext = context;
    mCurrentPeers = new ArraySet<>();
}

private void initNearConnect() {
    ArraySet<Host> peers = new ArraySet<>();
    peers.add(mParticipant);
    mNearConnect = new NearConnect.Builder()
            .forPeers(peers)
            .setContext(this)
            .setListener(getNearConnectListener(), Looper.getMainLooper()).build();
    mNearConnect.startReceiving();
}

private void startDiscovery() {
    mDiscovering = true;
    mNearDiscovery.startDiscovery();
    mDiscoveryInProgressSnackbar = Snackbar.make(binding.getRoot(), "Looking for chat participants",
            Snackbar.LENGTH_INDEFINITE);
    mDiscoveryInProgressSnackbar.show();
    mParticipantsAdapter.setData(new ArraySet<Host>());
    binding.participantsRv.setVisibility(View.VISIBLE);
    binding.discoveryPb.setVisibility(View.VISIBLE);
    binding.startChattingBtn.setText("Stop Searching");
}

/**
 * @param arraySet     The array set
 * @param index        the index at which the item needs to be fetched
 * @param defaultValue in case of array is null or index out of bound, return this value
 * @return item if found, defaultValue otherwise
 */
@Nullable
public static <T> T get(@Nullable ArraySet<T> arraySet, int index, @Nullable T defaultValue) {
    if (arraySet == null) {
        return defaultValue;
    }
    if (index >= arraySet.size()) {
        return defaultValue;
    }
    return arraySet.valueAt(index);
}

private void saveEvents(List<NotificationEvent> loadedEvents, NotificationEvent.Source source) {
    String prefKey = "";
    if (NotificationEvent.fromQms(source)) {
        prefKey = Preferences.Notifications.Data.QMS_EVENTS;
    } else if (NotificationEvent.fromTheme(source)) {
        prefKey = Preferences.Notifications.Data.FAVORITES_EVENTS;
    }

    Set<String> savedEvents = new ArraySet<>();
    for (NotificationEvent event : loadedEvents) {
        savedEvents.add(event.getSourceEventText());
    }
    App.get().getPreferences().edit().putStringSet(prefKey, savedEvents).apply();
}

@NonNull
@Override
public Set<String> getAvailableIDs() {
    ArraySet<String> set = new ArraySet<>();
    Collections.addAll(set, TimeZone.getAvailableIDs());
    return set;

}

public static void addToOpenedMenus(String menu) {
    ArraySet<String> set = new ArraySet<>();
    set.addAll(getPrefs().getStringSet("openedMenus", new ArraySet<String>()));
    if (set.contains(menu)) return;
    set.add(menu);

    getPrefs().edit().putStringSet("openedMenus", set).apply();
}

/**
 * Resolves transition information from geofencing intent
 *
 * @param intent geofencing intent
 * @return transition information
 * @throws RuntimeException if information cannot be resolved
 */
static GeoTransition resolveTransitionFromIntent(Intent intent) throws RuntimeException {
    GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
    if (geofencingEvent == null) {
        throw new RuntimeException("Geofencing event is null, cannot process");
    }

    if (geofencingEvent.hasError()) {
        if (geofencingEvent.getErrorCode() == GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE) {
            throw new GeofenceNotAvailableException();
        }
        throw new RuntimeException("ERROR: " + GeofenceStatusCodes.getStatusCodeString(geofencingEvent.getErrorCode()));
    }

    GeoEventType event = supportedTransitionEvents.get(geofencingEvent.getGeofenceTransition());
    if (event == null) {
        throw new RuntimeException("Transition is not supported: " + geofencingEvent.getGeofenceTransition());
    }

    Set<String> triggeringRequestIds = new ArraySet<>();
    for (Geofence geofence : geofencingEvent.getTriggeringGeofences()) {
        triggeringRequestIds.add(geofence.getRequestId());
    }

    Location location = geofencingEvent.getTriggeringLocation();
    return new GeoTransition(event, triggeringRequestIds, new GeoLatLng(location.getLatitude(), location.getLongitude()));
}

public static void addCampaignStatus(final Context context, final Set<String> finishedCampaignIds, final Set<String> suspendedCampaignIds) {
    PreferenceHelper.runTransaction(new PreferenceHelper.Transaction<Void>() {
        @Override
        public Void run() {
            PreferenceHelper.saveStringSet(context, MobileMessagingGeoProperty.FINISHED_CAMPAIGN_IDS.getKey(),
                    finishedCampaignIds != null ? finishedCampaignIds : new ArraySet<String>());
            PreferenceHelper.saveStringSet(context, MobileMessagingGeoProperty.SUSPENDED_CAMPAIGN_IDS.getKey(),
                    suspendedCampaignIds != null ? suspendedCampaignIds : new ArraySet<String>());
            return null;
        }
    });
}

/**
 * Generates set of geofencing reports
 *
 * @param context          context
 * @param signalingMessage original signaling message
 * @param areas            list of areas that triggered this geofencing event
 * @param event            transition type
 * @return set of geofencing reports to send to server
 */
private static Set<GeoReport> createReports(Context context, Message signalingMessage, List<Area> areas, @NonNull GeoEventType event, @NonNull GeoLatLng triggeringLocation) {
    Set<GeoReport> reports = new ArraySet<>();
    for (Area area : areas) {
        GeoReport report = createReport(signalingMessage, area, event, triggeringLocation);
        reports.add(report);
        MobileMessagingCore.getInstance(context).addGeneratedMessageIds(report.getMessageId());
    }
    return reports;
}

private CalendarEventData(Parcel in) {
    data = new CalendarData();
    data.calendar_id = in.readLong();
    ArrayList<String> list = new ArrayList<>();
    in.readList(list, null);
    data.conditions = new ArraySet<>(list);
}

@ValidData
@NonNull
@Override
public ConnectivityEventData getData() throws InvalidDataInputException {
    Set<Integer> checked = new ArraySet<>();
    for (int i = 0; i < checkBoxes.length; i++) {
        if (checkBoxes[i].isChecked()) {
            checked.add(values[i]);
        }
    }
    if (checked.size() == 0)
        throw new InvalidDataInputException();
    return new ConnectivityEventData(checked);
}