Java Code Examples for android.content.SharedPreferences#getLong()

public void saveDataAndClearMemory(List<TrackPoint> trackPoints, Long distance,boolean isLast){
    cacheDataToDatabase(trackPoints, isLast);
    //更新sp中的距离信息,单位为米
    SharedPreferences sp = GlobalApplication.getAppContext().getSharedPreferences(RMConfiguration.FILE_CONFIG, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    if(isLast){
        long total = sp.getLong(RMConfiguration.KEY_TOTAL_DISTANCE,0);
        total += distance;
        editor.putLong(RMConfiguration.KEY_TOTAL_DISTANCE,total);
        editor.putLong(RMConfiguration.KEY_TMP_DISTANCE,0);
        editor.apply();
    }
    else{
        editor.putLong(RMConfiguration.KEY_TMP_DISTANCE,distance);
        editor.apply();
    }
}
 

/**
 * 获取数据
 * @param context
 * @param key
 * @param defValue
 * @return
 */
public static Object get(Context context, String key, Object defValue) {
    SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
    if (defValue instanceof String) {
        return sp.getString(key, (String) defValue);
    } else if (defValue instanceof Integer) {
        return sp.getInt(key, (Integer) defValue);
    } else if (defValue instanceof Boolean) {
        return sp.getBoolean(key, (Boolean) defValue);
    } else if (defValue instanceof Float) {
        return sp.getFloat(key, (Float) defValue);
    } else if (defValue instanceof Long) {
        return sp.getLong(key, (Long) defValue);
    }
    return null;
}
 

/**
 * Returns the last time that a notification was shown (in UNIX time)
 *
 * @param context Used to access SharedPreferences
 * @return UNIX time of when the last notification was shown
 */
public static long getLastNotificationTimeInMillis(Context context) {
    /* Key for accessing the time at which Sunshine last displayed a notification */
    String lastNotificationKey = context.getString(R.string.pref_last_notification);

    /* As usual, we use the default SharedPreferences to access the user's preferences */
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);

    /*
     * Here, we retrieve the time in milliseconds when the last notification was shown. If
     * SharedPreferences doesn't have a value for lastNotificationKey, we return 0. The reason
     * we return 0 is because we compare the value returned from this method to the current
     * system time. If the difference between the last notification time and the current time
     * is greater than one day, we will show a notification again. When we compare the two
     * values, we subtract the last notification time from the current system time. If the
     * time of the last notification was 0, the difference will always be greater than the
     * number of milliseconds in a day and we will show another notification.
     */
    long lastNotificationTime = sp.getLong(lastNotificationKey, 0);

    return lastNotificationTime;
}
 

/**
 * 刷新经典模式可用心数量
 */
private static void updateClassicModeValidHeartCount(Context context) {
    SharedPreferences sharedPreferences = getSharedPreferences(context);
    if (sharedPreferences.getLong(CLASSIC_MODE_CURRENT_VALID_HEART_COUNT, MAX_HEART_COUNT) < MAX_HEART_COUNT) {
        long intervalTime = System.currentTimeMillis() - sharedPreferences.getLong(CLASSIC_MODE_HEART_LAST_UPDATE_TIME, 0);
        if (intervalTime > HEART_RECOVER_DURATION) {
            long recoverHeartCount = intervalTime / HEART_RECOVER_DURATION;
            if (recoverHeartCount > 0) {
                recoverHeartCount += sharedPreferences.getLong(CLASSIC_MODE_CURRENT_VALID_HEART_COUNT, MAX_HEART_COUNT);
                if (recoverHeartCount > MAX_HEART_COUNT) {
                    recoverHeartCount = MAX_HEART_COUNT;
                }
                saveClassicModeCurrentValidHeartCount(context, recoverHeartCount);
            }
        }
    }
}
 

/**
 * Returns the last time that a notification was shown (in UNIX time)
 *
 * @param context Used to access SharedPreferences
 * @return UNIX time of when the last notification was shown
 */
public static long getLastNotificationTimeInMillis(Context context) {
    /* Key for accessing the time at which Sunshine last displayed a notification */
    String lastNotificationKey = context.getString(R.string.pref_last_notification);

    /* As usual, we use the default SharedPreferences to access the user's preferences */
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);

    /*
     * Here, we retrieve the time in milliseconds when the last notification was shown. If
     * SharedPreferences doesn't have a value for lastNotificationKey, we return 0. The reason
     * we return 0 is because we compare the value returned from this method to the current
     * system time. If the difference between the last notification time and the current time
     * is greater than one day, we will show a notification again. When we compare the two
     * values, we subtract the last notification time from the current system time. If the
     * time of the last notification was 0, the difference will always be greater than the
     * number of milliseconds in a day and we will show another notification.
     */
    long lastNotificationTime = sp.getLong(lastNotificationKey, 0);

    return lastNotificationTime;
}
 

/**
 * Returns the last time that a notification was shown (in UNIX time)
 *
 * @param context Used to access SharedPreferences
 * @return UNIX time of when the last notification was shown
 */
public static long getLastNotificationTimeInMillis(Context context) {
    /* Key for accessing the time at which Sunshine last displayed a notification */
    String lastNotificationKey = context.getString(R.string.pref_last_notification);

    /* As usual, we use the default SharedPreferences to access the user's preferences */
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);

    /*
     * Here, we retrieve the time in milliseconds when the last notification was shown. If
     * SharedPreferences doesn't have a value for lastNotificationKey, we return 0. The reason
     * we return 0 is because we compare the value returned from this method to the current
     * system time. If the difference between the last notification time and the current time
     * is greater than one day, we will show a notification again. When we compare the two
     * values, we subtract the last notification time from the current system time. If the
     * time of the last notification was 0, the difference will always be greater than the
     * number of milliseconds in a day and we will show another notification.
     */
    long lastNotificationTime = sp.getLong(lastNotificationKey, 0);

    return lastNotificationTime;
}
 

/**
 * 刷新 经典模式-导航 可用数量
 */
private static void updateClassicModeValidNavigationCount(Context context) {
    SharedPreferences sharedPreferences = getSharedPreferences(context);
    if (sharedPreferences.getLong(CLASSIC_MODE_CURRENT_VALID_NAVIGATION_COUNT, MAX_NAVIGATION_COUNT) < MAX_NAVIGATION_COUNT) {
        long intervalTime = System.currentTimeMillis() - sharedPreferences.getLong(CLASSIC_MODE_NAVIGATION_LAST_UPDATE_TIME, 0);
        if (intervalTime > NAVIGATION_RECOVER_DURATION) {
            long recoverNavigationCount = intervalTime / NAVIGATION_RECOVER_DURATION;
            if (recoverNavigationCount > 0) {
                recoverNavigationCount += sharedPreferences.getLong(CLASSIC_MODE_CURRENT_VALID_NAVIGATION_COUNT, MAX_NAVIGATION_COUNT);
                if (recoverNavigationCount > MAX_NAVIGATION_COUNT) {
                    recoverNavigationCount = MAX_NAVIGATION_COUNT;
                }
                saveClassicModeCurrentValidNavigationCount(context, recoverNavigationCount);
            }
        }
    }
}
 

/**
 * Retrieve internal id of call handler as saved in databases It should be
 * some negative < SipProfile.INVALID_ID number
 * 
 * @param ctxt Application context
 * @param packageName name of the call handler package
 * @return the id of this call handler in databases
 */
public static Long getAccountIdForCallHandler(Context ctxt, String packageName) {
    SharedPreferences prefs = ctxt.getSharedPreferences("handlerCache", Context.MODE_PRIVATE);

    long accountId = SipProfile.INVALID_ID;
    try {
        accountId = prefs.getLong(VIRTUAL_ACC_PREFIX + packageName, SipProfile.INVALID_ID);
    } catch (Exception e) {
        Log.e(THIS_FILE, "Can't retrieve call handler cache id - reset");
    }
    if (accountId == SipProfile.INVALID_ID) {
        // We never seen this one, add a new entry for account id
        int maxAcc = prefs.getInt(VIRTUAL_ACC_MAX_ENTRIES, 0x0);
        int currentEntry = maxAcc + 1;
        accountId = SipProfile.INVALID_ID - (long) currentEntry;
        Editor edt = prefs.edit();
        edt.putLong(VIRTUAL_ACC_PREFIX + packageName, accountId);
        edt.putInt(VIRTUAL_ACC_MAX_ENTRIES, currentEntry);
        edt.commit();
    }
    return accountId;
}
 

/**
 * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
 *
 * @param key
 * @param defaultObject
 * @return
 */
private static Object getParam(Context context, boolean isUserParams, String key, Object defaultObject) {
    String type = defaultObject.getClass().getSimpleName();
    SharedPreferences sp = getPref(context, isUserParams ? SP_FILE.USER : SP_FILE.APP);

    if ("String".equals(type)) {
        return sp.getString(key, (String) defaultObject);
    } else if ("Integer".equals(type)) {
        return sp.getInt(key, (Integer) defaultObject);
    } else if ("Boolean".equals(type)) {
        return sp.getBoolean(key, (Boolean) defaultObject);
    } else if ("Float".equals(type)) {
        return sp.getFloat(key, (Float) defaultObject);
    } else if ("Long".equals(type)) {
        return sp.getLong(key, (Long) defaultObject);
    }

    return null;
}
 

public long getLong(String keyZone, String key, long defaultValue) {
  if (null == this.context) {
    LOGGER.w("application context is null");
    return defaultValue;
  }
  SharedPreferences setting = this.context.getSharedPreferences(keyZone, Context.MODE_PRIVATE);
  return setting.getLong(key, defaultValue);
}
 

@Override
protected AccessToken doInBackground(Void... voids) {
    final SharedPreferences prefs =
            getSharedPreferences(PREFS, Context.MODE_PRIVATE);
    String tokenValue = prefs.getString(PREF_ACCESS_TOKEN_VALUE, null);
    long expirationTime = prefs.getLong(PREF_ACCESS_TOKEN_EXPIRATION_TIME, -1);

    // Check if the current token is still valid for a while
    if (tokenValue != null && expirationTime > 0) {
        if (expirationTime
                > System.currentTimeMillis() + ACCESS_TOKEN_EXPIRATION_TOLERANCE) {
            return new AccessToken(tokenValue, new Date(expirationTime));
        }
    }

    // ***** WARNING *****
    // In this sample, we load the credential from a JSON file stored in a raw resource
    // folder of this client app. You should never do this in your app. Instead, store
    // the file in your server and obtain an access token from there.
    // *******************
    final InputStream stream = getResources().openRawResource(R.raw.credential);
    try {
        final GoogleCredentials credentials = GoogleCredentials.fromStream(stream)
                .createScoped(SCOPE);
        final AccessToken token = credentials.refreshAccessToken();
        prefs.edit()
                .putString(PREF_ACCESS_TOKEN_VALUE, token.getTokenValue())
                .putLong(PREF_ACCESS_TOKEN_EXPIRATION_TIME,
                        token.getExpirationTime().getTime())
                .apply();
        return token;
    } catch (IOException e) {
        Log.e(TAG, "Failed to obtain access token.", e);
    }
    return null;
}
 

private static Object get(Context context, String key, Object defaultObj) {
    SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
    if(defaultObj instanceof String) return sp.getString(key, (String)defaultObj);
    else if(defaultObj instanceof Integer) return sp.getInt(key, (Integer)defaultObj);
    else if(defaultObj instanceof Boolean) return sp.getBoolean(key, (Boolean)defaultObj);
    else if(defaultObj instanceof Float) return sp.getFloat(key, (Float)defaultObj);
    else if(defaultObj instanceof Long) return sp.getLong(key, (Long)defaultObj);
    return defaultObj;
}
 

/**
 * Set firstLaunchDay if neccessary
 */
private void setFirstLaunchDay() {
    SharedPreferences preferences = context.getSharedPreferences(Const.SHARED_PREFERENCES, 0);
    long firstLaunchDay = preferences.getLong(Const.SHARED_PREFERENCES_DAYS, -1);
    if (firstLaunchDay == -1) {
        preferences.edit().putLong(Const.SHARED_PREFERENCES_DAYS, System.currentTimeMillis()).apply();
    }
}
 

/**
 * 初始化音频的数据
 */
private void initAudio() {
    // 获取service存储的数据
    recordingItem = new RecordingItem();
    SharedPreferences sharePreferences = mActivity.getSharedPreferences("sp_name_audio", MODE_PRIVATE);
    final String filePath = sharePreferences.getString("audio_path", "");
    long elpased = sharePreferences.getLong("elpased", 0);
    recordingItem.setFilePath(filePath);
    recordingItem.setLength((int) elpased);
}
 

public boolean saveLatestLaunchTime() {
    long t = System.currentTimeMillis();
    String date = StringUtils.timeString(t);
    String minutes = StringUtils.timeStringByMinutes(t);
    SharedPreferences sp = context.getSharedPreferences(FORCE_ALERT, 0);
    if (sp.getLong(PREF_CURRENTTIMEMILLIS, 0) != 0 && t - sp.getLong(PREF_CURRENTTIMEMILLIS, 0) < 300000) {
        return false;
    }
    Editor editor = sp.edit();
    editor.putLong(PREF_CURRENTTIMEMILLIS, t);
    editor.putString(PREF_LAUNCH_DATE, date);
    editor.putString(PREF_LAUNCH_MINUTE, minutes);
    editor.commit();
    return true;
}
 

/**
 * SP中读取long
 *
 * @param key 键
 * @return 存在返回对应值，不存在返回默认值-1
 */
public static long getLong(Context context, String key) {
    SharedPreferences sp = context.getSharedPreferences(key, Context.MODE_PRIVATE);
    long value;
    value = sp.getLong(key, -1L);
    return value;
}
 

private void checkTimeForAutoTheme(SharedPreferences preferences) {
    long toMs;
    long fromMs;
    boolean auto = preferences.getBoolean(SHP_SETTING.KEY_IS_AUTOMATIC_TIME_DARK_THEME, true);

    int offset = TimeZone.getDefault().getRawOffset() + TimeZone.getDefault().getDSTSavings();
    long now = System.currentTimeMillis() + offset;

    if (auto) {
        toMs = 28800000;
        fromMs = 68400000;
    } else {
        toMs = preferences.getLong(SHP_SETTING.KEY_SELECTED_MILISECOND_TO, 28800000);
        fromMs = preferences.getLong(SHP_SETTING.KEY_SELECTED_MILISECOND_FROM, 68400000);
    }

    try {
        String string1 = time(fromMs);
        Date time1 = new SimpleDateFormat("HH:mm:ss").parse(string1);

        String string2 = time(toMs);
        Date time2 = new SimpleDateFormat("HH:mm:ss").parse(string2);

        String someRandomTime = time(now);
        Date currentTime = new SimpleDateFormat("HH:mm:ss").parse(someRandomTime);

        if (currentTime.getTime() > time1.getTime() && currentTime.getTime() < time2.getTime()) {

            //checkes whether the current time is between 14:49:00 and 20:11:13.
            G.isDarkTheme = true;
            appBarColor = Theme.default_dark_appBarColor;
            notificationColor = Theme.default_dark_notificationColor;
            toggleButtonColor = Theme.default_dark_toggleButtonColor;
            attachmentColor = Theme.default_dark_attachmentColor;
            headerTextColor = Theme.default_dark_headerTextColor;
            G.progressColor = Theme.default_dark_progressColor;
        } else {
            G.isDarkTheme = false;
            appBarColor = Theme.default_appBarColor;
            notificationColor = Theme.default_notificationColor;
            toggleButtonColor = Theme.default_toggleButtonColor;
            attachmentColor = Theme.default_attachmentColor;
            headerTextColor = Theme.default_headerTextColor;
            G.progressColor = Theme.default_progressColor;
        }
    } catch (ParseException e) {
        e.printStackTrace();
    }

}
 

public long getUsageTimeBeforeDonation() {
	SharedPreferences preferences = getPreferences();
	return preferences.getLong(this.USAGE_TIME_BEFORE_DONATION, 1000 * 60 * 60); // Defaults to 1 hour
}
 

/**
 * Get the user preferred inactivity timeout
 *
 * @param ctx the application context
 * @return the value in milliseconds
 */
public static long getInactivityTimeout(@NonNull final Context ctx) {
    final SharedPreferences pref = getPref(ctx);
    return pref.getLong(INACTIVITY_TIMEOUT, SelfAwareConditions.DEFAULT_INACTIVITY_TIMEOUT);
}
 

/**
 * get long preferences
 *
 * @param context      context
 * @param key          The name of the preference to retrieve
 * @param defaultValue Value to return if this preference does not exist
 * @return The preference value if it exists, or defValue. Throws ClassCastException if there is a preference with
 * this name that is not a long
 */
public static long getLong(Context context, String key, long defaultValue) {
    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
    return settings.getLong(key, defaultValue);
}