import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
public static TypeOfDay makeTimeOfDay(DateTime whenDT, double lat, double lon, TimeZoneGetter tzGetter, Logger lg) {
	Location location = new Location(lat, lon);
	
	Calendar when = whenDT.toCalendar(Locale.US);
	DateTimeZone dtz = tzGetter.getTimeZone(new LatLonPair(lat,lon));
	String tzid = dtz.getID();
	LocalTime tod = new LocalTime(whenDT);
	
	SunriseSunsetCalculator calculator = new SunriseSunsetCalculator(location, tzid);
	Calendar rise = calculator.getNauticalSunriseCalendarForDate(when);
	Calendar set = calculator.getNauticalSunsetCalendarForDate(when);
	DateTime riseDatetime = (new DateTime(rise.getTime())).withZone(dtz);
	LocalTime risedt =  new LocalTime(riseDatetime);
	DateTime setDatetime = (new DateTime(set.getTime())).withZone(dtz);
	LocalTime setdt =  new LocalTime(setDatetime);
	
	if(tod.isBefore(risedt.minusMinutes(30))) return TypeOfDay.NIGHTTIME;
	if(tod.isBefore(risedt.plusMinutes(90))) return TypeOfDay.MORNING;
	if(tod.isBefore(setdt.minusMinutes(90))) return TypeOfDay.DAYTIME;
	if(tod.isBefore(setdt.plusMinutes(30))) return TypeOfDay.EVENING;
	return TypeOfDay.NIGHTTIME;
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
/**
 * Calculate the time of the next alert after {@link cal}.
 * 
 * @param cal
 * @return
 */
public Calendar calculateNextAlert(Calendar cal,
        SunsetDefinition sunsetDefinition, int offsetInMinutes,
        String locationString) {
	String[] parts = locationString.split(",");
	Location location = new Location(parts[0], parts[1]);
	SunriseSunsetCalculator calculator = new SunriseSunsetCalculator(
	        location, cal.getTimeZone());
	Calendar alertTime = getSunsetCalendar(cal, sunsetDefinition,
	        calculator);
	alertTime.add(Calendar.MINUTE, offsetInMinutes);
	// advance a day if alert time has already passed for today
	if (!alertTime.after(cal)) {
		Calendar calCopy = Calendar.getInstance(cal.getTimeZone());
		calCopy.setTime(cal.getTime());
		calCopy.add(Calendar.DATE, 1);
		alertTime = getSunsetCalendar(calCopy, sunsetDefinition, calculator);
		alertTime.add(Calendar.MINUTE, offsetInMinutes);
	}
	return alertTime;
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
private void createCalculator() throws ExecutionFailure {
    if (m_LatLong == null || m_LatLong.trim().length() == 0)
        throw new ExecutionFailure("Missing latitude and longitude");
    if (m_timeZoneIdentifier == null || m_timeZoneIdentifier.trim().length() == 0)
        throw new ExecutionFailure("Missing time zone identifier");

    String ll[] = m_LatLong.split(",");
    if (ll.length != 2)
        throw new ExecutionFailure("Illegal lat/long format, use 'long,lat'");

    ll[0] = ll[0].trim();
    ll[1] = ll[1].trim();

    // Location of sunrise/set, as latitude/longitude.
    Location location = new Location(ll[0], ll[1]);
    // Create m_calculator object with the location and time zone
    // identifier.
    m_calculator = new SunriseSunsetCalculator(location,
            m_timeZoneIdentifier);
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
public static Pair<String, String> getSunriseAndSunset(Location location, String timezone) {
    SunriseSunsetCalculator calculator = new SunriseSunsetCalculator(
            new com.luckycatlabs.sunrisesunset.dto.Location(location.getLatitude(), location.getLongitude()),
            timezone
    );
    String officialSunriseString = calculator.getOfficialSunriseForDate(Calendar.getInstance());
    String officialSunsetString = calculator.getOfficialSunsetForDate(Calendar.getInstance());
    officialSunrise = calculator.getOfficialSunriseCalendarForDate(Calendar.getInstance());
    officialSunset = calculator.getOfficialSunsetCalendarForDate(Calendar.getInstance());
    return new Pair<>(officialSunriseString, officialSunsetString);
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
public static void refreshSunriseSunsetTime(Context context) {
    String[] latLong = getLatLong(context);

    if(latLong != null) {
        SharedPreferences pref = getSharedPreferences(context);
        com.luckycatlabs.sunrisesunset.dto.Location location = new com.luckycatlabs.sunrisesunset.dto.Location(latLong[0], latLong[1]);
        SunriseSunsetCalculator calculator = new SunriseSunsetCalculator(location, pref.getString("time_zone", TimeZone.getDefault().getID()));

        SharedPreferences.Editor editor = pref.edit();
        editor.putString("start_time", calculator.getOfficialSunsetForDate(Calendar.getInstance()));
        editor.putString("end_time", calculator.getOfficialSunriseForDate(Calendar.getInstance()));

        editor.apply();
    }
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
private Calendar getSunsetCalendar(Calendar cal,
        SunsetDefinition sunsetDefinition,
        SunriseSunsetCalculator calculator) {
	switch (sunsetDefinition) {
	case OFFICIAL:
		return calculator.getOfficialSunsetCalendarForDate(cal);
	case CIVIL:
	default:
		return calculator.getCivilSunsetCalendarForDate(cal);
	}
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
/**
 * Computes sunset and sunrise time and saves in the preference
 * @param context Ok where was the shrug emoji again?
 * @param onComputeCompleteListener OnComputeListener to invoke when compute is completed
 * @return Current instance
 */
public TwilightManager computeAndSaveTime(Context context, OnComputeCompleteListener onComputeCompleteListener) {
    Location mLocation = new Location(latitude, longitude);

    SunriseSunsetCalculator sunriseSunsetCalculator = new SunriseSunsetCalculator(mLocation, TimeZone.getDefault());
    Calendar calendar = Calendar.getInstance();

    String sunsetTime = sunriseSunsetCalculator.getOfficialSunsetForDate(calendar);
    String sunriseTime = sunriseSunsetCalculator.getOfficialSunriseForDate(calendar);

    PreferenceHelper.putString(context, Constants.PREF_START_TIME, sunsetTime);
    PreferenceHelper.putString(context, Constants.PREF_END_TIME, sunriseTime);

    AlarmUtils.setAlarms(context, sunsetTime, sunriseTime, false);

    if (onComputeCompleteListener != null) onComputeCompleteListener.onComputeComplete();;

    return this;
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
public void setLocation(Location location) {
    double distance = Math.round(GeoUtils.distance(curlat, curlon, location.getLatitude(), location.getLongitude()));
    Log.d(TAG, "setLocation " + location + " distance moved " + distance);
    curLocation = location;
    curlat = location.getLatitude();
    curlon = location.getLongitude();
    m_prefs.edit().putFloat("latitude", (float)curlat).putFloat("longitude", (float)curlon).apply();
    Calendar today = Calendar.getInstance();
    com.luckycatlabs.sunrisesunset.dto.Location lcLocation = new com.luckycatlabs.sunrisesunset.dto.Location(curlat, curlon);
    SunriseSunsetCalculator calculator = new SunriseSunsetCalculator(lcLocation, today.getTimeZone());
    Calendar sunrise = calculator.getOfficialSunriseCalendarForDate(today);
    Calendar sunset = calculator.getOfficialSunsetCalendarForDate(today);
    if (sunrise == null) {
        sunriseHour = 0;
        sunsetMinute = 0;
    } else {
        Log.d(TAG, "sunrise " + sunrise.getTime() + ", sunset " + sunset.getTime());
        sunriseHour = sunrise.get(Calendar.HOUR_OF_DAY);
        sunriseMinute = sunrise.get(Calendar.MINUTE);
    }
    if (sunset == null) {
        sunsetHour = 0;
        sunsetMinute = 0;
    } else {
        sunsetHour = sunset.get(Calendar.HOUR_OF_DAY);
        sunsetMinute = sunset.get(Calendar.MINUTE);
    }
    for (WeatherListener l : m_listeners)
        l.updateSunriseSunset(sunriseHour, sunriseMinute, sunsetHour, sunsetMinute);
    if (curLocationDistance < 0 || distance > m_locationThreshold)
        updateWeather(true); // immediately because we know the location has changed, substantially enough
    boolean locationNameFound = false;
    curLocationName = "";
    curLocationDistance = -1;
    if (!m_database.openRW())
        Log.e(TAG, "failed to open database");
    else {
        Address here = m_database.getNearestLocation(curlat, curlon);
        Log.d(TAG, "locality from database: " + here);
        if (here != null) {
            addLocality(here.getLocality(), here.getCountryCode(), here.getLatitude(), here.getLongitude(),
                    (int)Math.round(GeoUtils.distance(curlat, curlon, here.getLatitude(), here.getLongitude())));
            locationNameFound = true;
        }
    }
    if (!locationNameFound) {
        Log.d(TAG, "locality unknown, asking Gisgraphy");
        geocoderTask = new GisgraphySearchTask(this) {
            @Override
            protected void onPostExecute(List<Address> addrs) {
                super.onPostExecute(addrs);
                geocoderTask = null;
            }
        };
        geocoderTask.execute(curLocation);
    }
    ++m_locationUpdateCount;
}
 

import com.luckycatlabs.sunrisesunset.SunriseSunsetCalculator; //导入依赖的package包/类
protected SunriseSunsetCalculator getCalculator() throws ExecutionFailure {
    if (m_calculator == null)
        createCalculator();
    return m_calculator;
}