I use this code for checking:

public static boolean isLocationEnabled(Context context) {
    int locationMode = 0;
    String locationProviders;

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){
        try {
            locationMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE);

        } catch (SettingNotFoundException e) {
            e.printStackTrace();
            return false;
        }

        return locationMode != Settings.Secure.LOCATION_MODE_OFF;

    }else{
        locationProviders = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
        return !TextUtils.isEmpty(locationProviders);
    }


} 

Is your code working ? But you are asking about when do you need to check GPS ?? It depends on your goal, what your app is responsible for, if it is GPS tracker, you can check it when first activity starts, or if is not major function in your app, you can just notify but continue working.

I have dealt with the same problem of checking GPS, there are two types of GPS providers available in Android Framework now :

1. Using Google Play Services (it is recommended to use)
2. Using old Location Manager

So I have implemented two strategies for the case when device doesn't have google play services installed.

Base Strategy interface.

public interface BaseLocationStrategy {
    void startListeningForLocationChanges(LocationChangesListener locationListener);

    void stopListeningForLocationChanges();

    void setPeriodicalUpdateEnabled(boolean enable);

    void setPeriodicalUpdateTime(long time);

    Location getLastLocation();

    void initLocationClient();

}

Location change listener interface

public interface LocationChangesListener {
    void onLocationChanged(Location location);
    void onConnected();
    void onConnectionStatusChanged();
    void onFailure(String failureMessage);

}

And concrete implementation

public class GooglePlayServiceLocationStrategy implements
        BaseLocationStrategy,
        GoogleApiClient.ConnectionCallbacks,
        GoogleApiClient.OnConnectionFailedListener,
        LocationListener {
    private Context mAppContext;
    private Location mLastLocation;
    private GoogleApiClient mGoogleApiClient;
    private LocationChangesListener mLocationListener;
    private boolean mUpdatePeriodically = false;
    private LocationRequest mLocationRequest;
    private static GooglePlayServiceLocationStrategy INSTANCE;
    // Location updates intervals in sec
    private static long UPDATE_INTERVAL = 10000; // 10 sec
    private static long FASTEST_INTERVAL = 5000; // 5 sec
    private static long DISPLACEMENT = 10; // 10 meters

    private GooglePlayServiceLocationStrategy(Context context) {
        this.mAppContext = context;
    }

    @Override
    public void startListeningForLocationChanges(LocationChangesListener locationListener) {
        this.mLocationListener = locationListener;
        if (mGoogleApiClient != null) {
            mGoogleApiClient.connect();
        }
    }

    @Override
    public void stopListeningForLocationChanges() {
        mLocationListener = null;
        if (mGoogleApiClient.isConnected()) {
            stopLocationUpdates();
            mGoogleApiClient.disconnect();
        }
    }

    public static BaseLocationStrategy getInstance(Context context) {
        if (INSTANCE == null) {
            INSTANCE = new GooglePlayServiceLocationStrategy(context);
            INSTANCE.initLocationClient();
        }
        return INSTANCE;
    }

    @Override
    public void setPeriodicalUpdateEnabled(boolean enable) {
        this.mUpdatePeriodically = enable;
    }

    @Override
    public void setPeriodicalUpdateTime(long time) {
        UPDATE_INTERVAL = time < FASTEST_INTERVAL ? FASTEST_INTERVAL : time;
    }

    @Override
    public Location getLastLocation() {
        return this.mLastLocation;
    }

    @Override
    public void initLocationClient() {
        mGoogleApiClient = buildGoogleApiClient();
        mLocationRequest = createLocationRequest();
    }

    protected synchronized GoogleApiClient buildGoogleApiClient() {
        return new GoogleApiClient.Builder(mAppContext)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API).build();
    }

    @Override
    public void onConnected(Bundle bundle) {
        mLocationListener.onConnected();
        mLastLocation = LocationServices.FusedLocationApi
                .getLastLocation(mGoogleApiClient);
        if (mUpdatePeriodically) {
            startLocationUpdates();
        }
    }

    @Override
    public void onConnectionSuspended(int i) {
        mLocationListener.onConnectionStatusChanged();
    }

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {
        mLocationListener.onFailure(connectionResult.getErrorMessage());
    }

    /**
     * Starting the location updates
     */
    protected void startLocationUpdates() {
        LocationServices.FusedLocationApi.requestLocationUpdates(
                mGoogleApiClient, mLocationRequest, this);
    }

    /**
     * Creating location request object
     */
    protected LocationRequest createLocationRequest() {
        LocationRequest locationRequest = new LocationRequest();
        locationRequest.setInterval(UPDATE_INTERVAL);
        locationRequest.setFastestInterval(FASTEST_INTERVAL);
        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        locationRequest.setSmallestDisplacement(DISPLACEMENT); // 10 meters
        return locationRequest;
    }

    /**
     * Stopping location updates
     */
    protected void stopLocationUpdates() {
        LocationServices.FusedLocationApi.removeLocationUpdates(
                mGoogleApiClient, this);
    }

    @Override
    public void onLocationChanged(Location location) {
        mLastLocation = location;
        mLocationListener.onLocationChanged(location);
    }


}

And finally for old way

public class LocationManagerStrategy implements BaseLocationStrategy, LocationListener {
    private Context mAppContext;
    private LocationManager mLocationManager;
    private Location mLastLocation;
    private LocationChangesListener mLocationListener;
    private boolean mUpdatePeriodically = false;
    private static LocationManagerStrategy INSTANCE;
    // Location updates intervals in sec
    private static long UPDATE_INTERVAL = 10000; // 10 sec
    private static long FASTEST_INTERVAL = 5000; // 5 sec
    private static long DISPLACEMENT = 10; // 10 meters

    private LocationManagerStrategy(Context context) {
        this.mAppContext = context;
    }

    public static LocationManagerStrategy getInstance(Context context) {
        if (INSTANCE == null) {
            INSTANCE = new LocationManagerStrategy(context);
            INSTANCE.initLocationClient();
        }
        return INSTANCE;
    }

    @Override
    public void startListeningForLocationChanges(LocationChangesListener locationListener) {
        mLocationListener = locationListener;
        try {

            mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,
                    UPDATE_INTERVAL,
                    DISPLACEMENT, this);
        } catch (SecurityException ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void stopListeningForLocationChanges() {
        try {
            mLocationManager.removeUpdates(this);
        } catch (SecurityException ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void setPeriodicalUpdateEnabled(boolean enable) {
        mUpdatePeriodically = enable;
    }

    @Override
    public void setPeriodicalUpdateTime(long time) {
        UPDATE_INTERVAL = time;
    }

    @Override
    public Location getLastLocation() {
        if (mLastLocation == null) {
            try {
                mLastLocation = mLocationManager.getLastKnownLocation(getBestProvider());
            } catch (SecurityException securityException) {
                return null;
            }
        }
        return mLastLocation;
    }

    private String getBestProvider() {
        Criteria criteria = new Criteria();
        return mLocationManager.getBestProvider(criteria, false);
    }

    @Override
    public void initLocationClient() {
        mLocationManager = (LocationManager) mAppContext.getSystemService(Context.LOCATION_SERVICE);
    }

    @Override
    public void onLocationChanged(Location location) {
        mLastLocation = location;
        mLocationListener.onLocationChanged(location);
        if (!mUpdatePeriodically) {
            this.stopListeningForLocationChanges();
        }
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
        mLocationListener.onConnectionStatusChanged();
    }

    @Override
    public void onProviderEnabled(String provider) {
        mLocationListener.onConnected();
    }

    @Override
    public void onProviderDisabled(String provider) {
        mLocationListener.onFailure(provider);
    }
}

may be this will be useful check this site it discusses about location service

http://www.scotthelme.co.uk/android-location-services/

See SettingsApi: check your location request then ensure that the device's system settings are properly configured for the app's location needs.

There should be one change, where you check TextUtils.isEmpty(locationProviders). It is never empty. Where there is no provider (location settings are disabled) it has value "null". Yes I mean value "null", not null.