import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的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.dto.Location; //导入依赖的package包/类
@Override
protected void onUpdateData(int reason) {
    Log.d(TAG, "sunrise onUpdateData: " + sLocationCriteria.toString());
    LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    String provider = lm.getBestProvider(sLocationCriteria, true);
    if (TextUtils.isEmpty(provider)) {
        Log.d(TAG, "No available location providers matching criteria." + lm.getAllProviders());
        return;
    }

    final android.location.Location lastLocation = lm.getLastKnownLocation(provider);

    if (lastLocation == null ||
            (SystemClock.elapsedRealtimeNanos() - lastLocation.getElapsedRealtimeNanos())
                    >= STALE_LOCATION_NANOS) {
        Log.d(TAG, "Stale or missing last-known location; requesting single coarse location "
                + "update.");
        disableOneTimeLocationListener();
        mOneTimeLocationListenerActive = true;
        lm.requestSingleUpdate(provider, mOneTimeLocationListener, null);
    } else {
        publishUpdate(lastLocation);
    }

}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的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.dto.Location; //导入依赖的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.dto.Location; //导入依赖的package包/类
public void setup(int month, int day, int year, String longitude, String latitude, String timeZoneIdentifier) {
    eventDate = Calendar.getInstance();
    eventDate.set(Calendar.YEAR, year);
    eventDate.set(Calendar.MONTH, month);
    eventDate.set(Calendar.DAY_OF_MONTH, day);
    eventDate.setTimeZone(TimeZone.getTimeZone(timeZoneIdentifier));
    location = new Location(longitude, latitude);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
private Location createLocation(String fileName) {
    String[] latlong = fileName.split("\\-");
    String latitude = latlong[0].replace('_', '.');
    String longitude = latlong[1].replace('_', '.');

    if (latitude.endsWith("S")) {
        latitude = "-" + latitude;
    }
    if (longitude.endsWith("W")) {
        longitude = "-" + longitude;
    }
    latitude = latitude.substring(0, latitude.length() - 1);
    longitude = longitude.substring(0, longitude.length() - 1);
    return new Location(latitude, longitude);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
public static boolean isSunDown(SharedPreferences settings)
{
	double latitude = settings.getFloat(PebbleNotificationCenter.LATITUDE, 0);
	double longitude = settings.getFloat(PebbleNotificationCenter.LONGITUDE, 0);


	Location location = new Location(latitude, longitude);
	SunriseSunsetCalculator sunriseSunsetCalculator = new SunriseSunsetCalculator(location, TimeZone.getDefault());

	boolean sunUp = TimeUtil.isBetweenTimes(Calendar.getInstance(),
			sunriseSunsetCalculator.getCivilSunriseCalendarForDate(Calendar.getInstance()),
			sunriseSunsetCalculator.getCivilSunsetCalendarForDate(Calendar.getInstance()));

	return !sunUp;
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的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.dto.Location; //导入依赖的package包/类
@Override
public void onLocationChanged(android.location.Location location) {
    publishUpdate(location);
    disableOneTimeLocationListener();
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Constructs a new <code>SunriseSunsetCalculator</code> with the given <code>Location</code>
 * 
 * @param location
 *            <code>Location</code> object containing the Latitude/Longitude of the location to compute
 *            the sunrise/sunset for.
 * @param timeZoneIdentifier
 *            String identifier for the timezone to compute the sunrise/sunset times in. In the form
 *            "America/New_York". Please see the zi directory under the JDK installation for supported
 *            time zones.
 */
public SunriseSunsetCalculator(Location location, String timeZoneIdentifier) {
    this.calculator = new SolarEventCalculator(location, timeZoneIdentifier);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Computes the sunrise for an arbitrary declination.
 * 
 * @param latitude
 * @param longitude
 *            Coordinates for the location to compute the sunrise/sunset for.
 * @param timeZone
 *            timezone to compute the sunrise/sunset times in.
 * @param date
 *            <code>Calendar</code> object containing the date to compute the official sunset for.
 * @param degrees
 *            Angle under the horizon for which to compute sunrise. For example, "civil sunrise"
 *            corresponds to 6 degrees.
 * @return the requested sunset time as a <code>Calendar</code> object.
 */

public static Calendar getSunrise(double latitude, double longitude, TimeZone timeZone, Calendar date, double degrees) {
    SolarEventCalculator solarEventCalculator = new SolarEventCalculator(new Location(latitude, longitude), timeZone);
    return solarEventCalculator.computeSunriseCalendar(new Zenith(90 - degrees), date);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Computes the sunset for an arbitrary declination.
 * 
 * @param latitude
 * @param longitude
 *            Coordinates for the location to compute the sunrise/sunset for.
 * @param timeZone
 *            timezone to compute the sunrise/sunset times in.
 * @param date
 *            <code>Calendar</code> object containing the date to compute the official sunset for.
 * @param degrees
 *            Angle under the horizon for which to compute sunrise. For example, "civil sunset"
 *            corresponds to 6 degrees.
 * @return the requested sunset time as a <code>Calendar</code> object.
 */

public static Calendar getSunset(double latitude, double longitude, TimeZone timeZone, Calendar date, double degrees) {
    SolarEventCalculator solarEventCalculator = new SolarEventCalculator(new Location(latitude, longitude), timeZone);
    return solarEventCalculator.computeSunsetCalendar(new Zenith(90 - degrees), date);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Returns the location where the sunrise/sunset is calculated for.
 * 
 * @return <code>Location</code> object representing the location of the computed sunrise/sunset.
 */
public Location getLocation() {
    return location;
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Constructs a new <code>SolarEventCalculator</code> using the given parameters.
 * 
 * @param location
 *            <code>Location</code> of the place where the solar event should be calculated from.
 * @param timeZoneIdentifier
 *            time zone identifier of the timezone of the location parameter. For example,
 *            "America/New_York".
 */
public SolarEventCalculator(Location location, String timeZoneIdentifier) {
    this.location = location;
    this.timeZone = TimeZone.getTimeZone(timeZoneIdentifier);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Constructs a new <code>SunriseSunsetCalculator</code> with the given
 * <code>Location</code>
 * 
 * @param location
 *            <code>Location</code> object containing the Latitude/Longitude
 *            of the location to compute the sunrise/sunset for.
 * @param timeZoneIdentifier
 *            String identifier for the timezone to compute the
 *            sunrise/sunset times in. In the form "America/New_York".
 *            Please see the zi directory under the JDK installation for
 *            supported time zones.
 */
public SunriseSunsetCalculator(Location location, String timeZoneIdentifier) {
	this.calculator = new SolarEventCalculator(location, timeZoneIdentifier);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Computes the sunrise for an arbitrary declination.
 * 
 * @param latitude
 * @param longitude
 *            Coordinates for the location to compute the sunrise/sunset
 *            for.
 * @param timeZone
 *            timezone to compute the sunrise/sunset times in.
 * @param date
 *            <code>Calendar</code> object containing the date to compute
 *            the official sunset for.
 * @param degrees
 *            Angle under the horizon for which to compute sunrise. For
 *            example, "civil sunrise" corresponds to 6 degrees.
 * @return the requested sunset time as a <code>Calendar</code> object.
 */

public static Calendar getSunrise(double latitude, double longitude, TimeZone timeZone, Calendar date, double degrees) {
	SolarEventCalculator solarEventCalculator = new SolarEventCalculator(new Location(latitude, longitude), timeZone);
	return solarEventCalculator.computeSunriseCalendar(new Zenith(90 - degrees), date);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Computes the sunset for an arbitrary declination.
 * 
 * @param latitude
 * @param longitude
 *            Coordinates for the location to compute the sunrise/sunset
 *            for.
 * @param timeZone
 *            timezone to compute the sunrise/sunset times in.
 * @param date
 *            <code>Calendar</code> object containing the date to compute
 *            the official sunset for.
 * @param degrees
 *            Angle under the horizon for which to compute sunrise. For
 *            example, "civil sunset" corresponds to 6 degrees.
 * @return the requested sunset time as a <code>Calendar</code> object.
 */

public static Calendar getSunset(double latitude, double longitude, TimeZone timeZone, Calendar date, double degrees) {
	SolarEventCalculator solarEventCalculator = new SolarEventCalculator(new Location(latitude, longitude), timeZone);
	return solarEventCalculator.computeSunsetCalendar(new Zenith(90 - degrees), date);
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Returns the location where the sunrise/sunset is calculated for.
 * 
 * @return <code>Location</code> object representing the location of the
 *         computed sunrise/sunset.
 */
public Location getLocation() {
	return location;
}
 

import com.luckycatlabs.sunrisesunset.dto.Location; //导入依赖的package包/类
/**
 * Constructs a new <code>SolarEventCalculator</code> using the given
 * parameters.
 * 
 * @param location
 *            <code>Location</code> of the place where the solar event
 *            should be calculated from.
 * @param timeZoneIdentifier
 *            time zone identifier of the timezone of the location
 *            parameter. For example, "America/New_York".
 */
public SolarEventCalculator(Location location, String timeZoneIdentifier) {
	this.location = location;
	this.timeZone = TimeZone.getTimeZone(timeZoneIdentifier);
}