Android 在每天的特定时间调用方法

嗨，我有一个全屏应用程序； 弗斯特 我想，例如，下午6点隐藏所有对象，然后在特定时间再次显示它们，每天。基于设备时间

---

第二，我想每15分钟发送一次状态和GPS信息，我有一个方法，但如何每15分钟调用一次呢？

要安排一个定期任务，可以使用带有计时器任务的计时器

看

对于你的第二个问题，从现在开始每15分钟做一件事：

long INTERVAL_MSEC = 900000;
Timer timer = new Timer();
TimerTask task = new TimerTask() {
    public void run() {
        sendStatusAndGPS();
    }
}
timer.scheduleAtFixedRate(task, 0, INTERVAL_MSEC);

对于第一个问题，您可以将开始时间作为第二个参数传递给timer.scheduleAtFixedRate

---

您还可以将处理程序与PostAttribute方法一起使用。

要计划周期性任务，您可以将计时器与TimerTask一起使用

看

对于你的第二个问题，从现在开始每15分钟做一件事：

long INTERVAL_MSEC = 900000;
Timer timer = new Timer();
TimerTask task = new TimerTask() {
    public void run() {
        sendStatusAndGPS();
    }
}
timer.scheduleAtFixedRate(task, 0, INTERVAL_MSEC);

对于第一个问题，您可以将开始时间作为第二个参数传递给timer.scheduleAtFixedRate

---

您还可以将处理程序与PostAttribute方法一起使用。

正如nitegazer2003所说，您可以使用：

公共作废计划（TimerTask任务、日期、时间、长周期）

但是，如果您想为一天中的特定小时启动重复计时器，则必须设置when变量， 例如，如果您希望计时器每天在6点重复，您可以执行以下操作：

// get today date
    Date curent_time= new Date(System.currentTimeMillis());
    Calendar cal = Calendar.getInstance();
    cal.setTime(curent_time);
    int hour = cal.get(Calendar.HOUR);
    int min = cal.get(Calendar.MINUTE);
    int sec = cal.get(Calendar.SECOND);

    long when = (6 * 3600)
    - ( (hour*3600) + (min *60) + sec);
// interval should be based on miliseconds so
    long interval = 24*60*60*1000;
    timer.scheduleAtFixedRate(new testtimertask(), when, interval);

---

<> P>但你需要考虑CurtNeTimeTimes不是你的启动时间，如果是的话，你应该使用另一个公式来计算何时启动计时器。p> 正如nitegazer2003所说，您可以使用：

公共作废计划（TimerTask任务、日期、时间、长周期）

但是，如果您想为一天中的特定小时启动重复计时器，则必须设置when变量， 例如，如果您希望计时器每天在6点重复，您可以执行以下操作：

// get today date
    Date curent_time= new Date(System.currentTimeMillis());
    Calendar cal = Calendar.getInstance();
    cal.setTime(curent_time);
    int hour = cal.get(Calendar.HOUR);
    int min = cal.get(Calendar.MINUTE);
    int sec = cal.get(Calendar.SECOND);

    long when = (6 * 3600)
    - ( (hour*3600) + (min *60) + sec);
// interval should be based on miliseconds so
    long interval = 24*60*60*1000;
    timer.scheduleAtFixedRate(new testtimertask(), when, interval);

---

<> P>但你需要考虑CurtNeTimeTimes不是你的启动时间，如果是的话，你应该使用另一个公式来计算何时启动计时器。p> 因此，您需要一个唤醒应用程序的调度选项，因此您应该使用

AlarmManager

来执行此操作，您应该看看

其想法是，您创建一个每30分钟呼叫一次的服务，并在该服务中写入您的GPS位置代码

这是我在LocationService.Class中的代码

public class LocationService extends Service
{

    private class LocationListener implements android.location.LocationListener
    {
        Location mLastLocation;

        public LocationListener(String provider)
        {
            Log.e(TAG, "LocationListener " + provider);
            mLastLocation = new Location(provider);
        }

        @Override
        public void onLocationChanged(Location currentLocation)
        {
            sendAllLocationsToServer();
        }

        @Override
        public void onProviderDisabled(String provider)
        {
            Log.e(TAG, "onProviderDisabled: " + provider);
        }

        @Override
        public void onProviderEnabled(String provider)
        {
            Log.e(TAG, "onProviderEnabled: " + provider);
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras)
        {
            Log.e(TAG, "onStatusChanged: " + provider);
        }
    }

    private void sendAllLocationsToServer() {
        //send locations to server
    }

    LocationListener[] mLocationListeners = new LocationListener[] {
            new LocationListener(LocationManager.GPS_PROVIDER),
            new LocationListener(LocationManager.NETWORK_PROVIDER)
    };

    @Override
    public IBinder onBind(Intent arg0)
    {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        Log.e(TAG, "onStartCommand");
        super.onStartCommand(intent, flags, startId);
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // TODO: Consider calling
            //    ActivityCompat#requestPermissions
            // here to request the missing permissions, and then overriding
            //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
            //                                          int[] grantResults)
            // to handle the case where the user grants the permission. See the documentation
            // for ActivityCompat#requestPermissions for more details.
            return START_STICKY;
        }
        if (mLocationManager == null) {
            initializeLocationManager();
            try {
                mLocationManager.requestLocationUpdates(
                        LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                        mLocationListeners[1]);
            } catch (java.lang.SecurityException ex) {
                Log.i(TAG, "fail to request location update, ignore", ex);
            } catch (IllegalArgumentException ex) {
                Log.d(TAG, "network provider does not exist, " + ex.getMessage());
            }
            try {
                mLocationManager.requestLocationUpdates(
                        LocationManager.GPS_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                        mLocationListeners[0]);
            } catch (java.lang.SecurityException ex) {
                Log.i(TAG, "fail to request location update, ignore", ex);
            } catch (IllegalArgumentException ex) {
                Log.d(TAG, "gps provider does not exist " + ex.getMessage());
            }
        } else {
            /*try {
                mLocationManager.requestLocationUpdates(
                        LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                        mLocationListeners[1]);
            } catch (java.lang.SecurityException ex) {
                Log.i(TAG, "fail to request location update, ignore", ex);
            } catch (IllegalArgumentException ex) {
                Log.d(TAG, "network provider does not exist, " + ex.getMessage());
            }*/
            try {
                mLocationManager.requestLocationUpdates(
                        LocationManager.GPS_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                        mLocationListeners[0]);
            } catch (java.lang.SecurityException ex) {
                Log.i(TAG, "fail to request location update, ignore", ex);
            } catch (IllegalArgumentException ex) {
                Log.d(TAG, "gps provider does not exist " + ex.getMessage());
            }
            try {
                mLocationManager.requestLocationUpdates(
                        LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                        mLocationListeners[1]);
            } catch (java.lang.SecurityException ex) {
                Log.i(TAG, "fail to request location update, ignore", ex);
            } catch (IllegalArgumentException ex) {
                Log.d(TAG, "network provider does not exist, " + ex.getMessage());
            }
        }
        return START_STICKY;
    }

    public void cancelService(){
        AlarmManager alarmMgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
        Intent alarmIntent = new Intent(getApplicationContext(), LocationService.class);
        alarmIntent.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
        PendingIntent pendingIntent = PendingIntent.getService(getApplicationContext(), 0,
                alarmIntent, 0);
        alarmMgr.cancel(pendingIntent);
    }

    @Override
    public void onCreate()
    {
        Log.e(TAG, "onCreate");
        //TODO should implement an stop point for this service
        initializeLocationManager();
        try {
            mLocationManager.requestLocationUpdates(
                    LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                    mLocationListeners[1]);
        } catch (java.lang.SecurityException ex) {
            Log.i(TAG, "fail to request location update, ignore", ex);
        } catch (IllegalArgumentException ex) {
            Log.d(TAG, "network provider does not exist, " + ex.getMessage());
        }
        try {
            mLocationManager.requestLocationUpdates(
                    LocationManager.GPS_PROVIDER, LOCATION_INTERVAL, LOCATION_DISTANCE,
                    mLocationListeners[0]);
        } catch (java.lang.SecurityException ex) {
            Log.i(TAG, "fail to request location update, ignore", ex);
        } catch (IllegalArgumentException ex) {
            Log.d(TAG, "gps provider does not exist " + ex.getMessage());
        }
    }

    @Override
    public void onDestroy()
    {
        Log.e(TAG, "onDestroy");
        super.onDestroy();
        if (mLocationManager != null) {
            for (int i = 0; i < mLocationListeners.length; i++) {
                try {
                    mLocationManager.removeUpdates(mLocationListeners[i]);
                } catch (Exception ex) {
                    Log.i(TAG, "fail to remove location listners, ignore", ex);
                }
            }
        }
        stopSelf();
    }

    private void initializeLocationManager() {
        Log.e(TAG, "initializeLocationManager");
        if (mLocationManager == null) {
            mLocationManager = (LocationManager) getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
        }
    }
}

公共类定位服务扩展服务
{
私有类LocationListener实现android.location.LocationListener
{
位置mLastLocation；
公共位置侦听器（字符串提供程序）
{
Log.e（标记“LocationListener”+提供者）；
mLastLocation=新位置（提供商）；
}
@凌驾
已更改位置上的公共无效（位置currentLocation）
{
sendAllLocationsToServer（）；
}
@凌驾
公共无效onProviderDisabled（字符串提供程序）
{
Log.e（标记“onProviderDisabled:+提供程序”）；
}
@凌驾
公共无效onProviderEnabled（字符串提供程序）
{
Log.e（标记“onProviderEnabled:+提供程序”）；
}
@凌驾
public void onStatusChanged（字符串提供程序、int状态、Bundle extra）
{
Log.e（标记“onStatusChanged:+提供者”）；
}
}
私有void sendAllLocationsToServer（）{
//将位置发送到服务器
}
LocationListener[]mlLocationListeners=新LocationListener[]{
新LocationListener（LocationManager.GPS_提供程序），
新LocationListener（LocationManager.NETWORK\u提供程序）
};
@凌驾
公共IBinder onBind（意图arg0）
{
返回null；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）
{
Log.e（标记“onStartCommand”）；
super.onStartCommand（intent、flags、startId）；
if（ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u FINE\u LOCATION）！=PackageManager.permission\u已授予和&ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u LOCATION）！=PackageManager.permission\u已授予）{
考虑到呼叫
//ActivityCompat#请求权限
//在此处请求缺少的权限，然后覆盖
//public void onRequestPermissionsResult（int-requestCode，字符串[]权限，
//int[]格兰特结果）
//处理用户授予权限的情况。请参阅文档
//对于ActivityCompat，请请求权限以获取更多详细信息。
返回开始时间；
}
if（mLocationManager==null）{
初始化ElocationManager（）；
试一试{
mLocationManager.RequestLocationUpdate(
LocationManager.NETWORK_提供程序、位置间隔、位置距离、，
mLocationListeners[1]）；
}catch（java.lang.SecurityException ex）{
Log.i（标记“无法请求位置更新，忽略”，例如）；
}捕获（IllegalArgumentException ex）{
Log.d（标记“网络提供商不存在”+ex.getMessage（））；
}
试一试{
mLocationManager.RequestLocationUpdate(
LocationManager.GPS\u提供程序、位置\u间隔、位置\u距离、，
mLocationListeners[0]）；
}catch（java.lang.SecurityException ex）{
Log.i（标记“无法请求位置更新，忽略”，例如）；
}捕获（IllegalArgumentException ex）{
Log.d（标记“gps提供程序不存在”+ex.getMessage（））；
}
}否则{
/*试一试{
mLocationManager.RequestLocationUpdate(
LocationManager.NETWORK_提供程序、位置间隔、位置距离、，
mLocationListeners[1]）；
}catch（java.lang.SecurityExe）