When trying to send a push alert through Parse.com, I came across the following warning:
Installations without a known timezone will not receive this campaign.
So, how do I make sure Parse knows a user's timezones? Is there any specific code, or does it to that without the need for code/by default, and this is a moot question?
Thanks!
This is recorded on a per-Installation basis by the Parse library, and should be automatically updated whenever it is updated by the client.
You can verify that Parse is saving time zones by logging into your account, selecting 'Core' (at top) and 'Installation' (at left). You'll see a list of all current installations - the relevant column is timeZone.
The notice that you see when attempting to send a push is just a general reminder, not an indication that there is necessarily anything wrong on your end.
UPDATE 3/1/2015:
I found a bug in this, BTW, that some people might run into. So I'm posting it here in case it might help somebody.
In the current version of Parse, there is a bug wherein an iOS device with their Date & Time "Set Automatically" setting disabled will (potentially) return a timeZone that Parse won't understand. In such an event, local-time scheduled push notifications will not be sent to a user with that setting turned off.
I verified this, myself, on two devices. With "Set Automatically" turned on the Parse Installation is set to "America/Los Angeles" (which is accurate for me). With it turned off, it sets it to "US/Pacific". This is still accurate, obviously, but for some reason Parse does not like that value.
I imagine there are a non-trivial number of iOS users with that setting disabled, so I hope Parse fixes this.
Related
I'm looking for a way to force a client computer to verify with our MDM filewave server preferably inside a script. Right now the only non gui way I have to force a verify on the client end, is by killing the fwcld service. This works well when ran directly on the client machine, but does not work when ran as a fileset from the filewave server.
The reason I need this, is because Kernel extension policies hang at "Handled via MDM" and will not activate until the next verification. This is way too slow when software is dependent on the kernel extension to install.
If anyone has a solution, either a script, or some other way to make the policy install quicker. I'd really appreciate. I've been banging my head against the wall for too long, the wall is looking pretty rough.
According to FileWave's documentation MDM-managed clients auto-verify with the FileWave server, based on the "tickle interval".
“waits for a specified amount of time (Tickle Interval … ) before it tries to connect again.”
By default this value is set to 120sec. The tickle interval can be changed by using the "SuperPrefs Editor". When using the SuperPrefs Editor only modify the values that you want to change.
Use these instructions to help you upload and apply the new FWpreferences to the (necessary) FileWave clients.
Link to Knowledgebase
**FileWave has moved the Knowledgebase. All links above have been updated. 9/21/22 **
I tried to create a program with an expired date, but if the date on the computer is changed, the expired date does not work anymore. how to solve it ?I made it using delphi
Need some more information to answer this effectively but it sounds like the issue occurs because the system is using the device's date/time/clock to determine the validity of dates.
The only way around this would be to hook into a webservice for an accurate date value that is then difficult to manipulate by changing the system clock.
There is another stackoverflow thread that addresses using internet time for these sorts of purposes:
Get internet time in delphi
I hope this helps!
I have location services working in iOS8.
It is set for kCLLocationAccuracyBest using startMonitoringSignificantLocationChanges to restart when in the background and startUpdatingLocation for accuracy.
When I set pausesLocationUpdatesAutomatically = YES, the location services get paused and resumed as expected. However, the following call to didUpdateLocations: only has one location in it.
I was expecting to receive a bunch of locations that were received by the OS while the delivery was paused. Am I missing something here? Does it have anything to do with deferredLocationUpdatesAvailable?
This answer talks about a post on Apple Dev Forum, but I get nothing when searching for pausesLocationUpdatesAutomatically.
Please note: this issue has nothing to do with calling requestAlwaysAuthorization or setting prompts in info.plist.
Further to the answer by Quentin Hayot...
The documentation for pausesLocationUpdatesAutomatically states:
Allowing the location manager to pause updates can improve battery life on the target device without sacrificing location data.
This is highly misleading.
What it really means is when location manager pauses it will sacrifice location data: the app does not get and never will get location updates until the location manager resumes.
It should explain that paused location updates are completely different from deferred location updates.
To improve battery life, the app should call allowDeferredLocationUpdatesUntilTraveled:timeout: which does deliver all location updates gathered while deferring to locationManager:didUpdateLocations:.
The documentation for locationManager:didUpdateLocations: states:
If updates were deferred or if multiple locations arrived before they could be delivered, the array may contain additional entries.
which is reasonably clear, but it could state that it has nothing to do with, and should not be confused with, pausesLocationUpdatesAutomatically.
When you pause the location updates, the system considers that you don't need the location for now. Resuming it will only give you the current location.
This is a normal behavior.
I am going to create a typical business application that will be used by a few hundred consultants. Normally, the consultants would be presented with an error message with a standard text. As the application will be a complicated one with lots of changes being made to it constantly I would like the following:
When an error message is presented, the user has the option to "send" the error message to the developers. The developers should be able to open the incoming file in i.e. Eclipse and debug the steps of the last 10 minutes of work step by step (one line at a time if they want to). Everything should be transparent, meaning that they for example should be able to see the return values of calls to the database.
Are there any solutions that offer such functionality today, my preferred language is Python or also Java. I know that there will be a huge performance hit because of such functionality, but that is acceptable as this kind of software is not performance sensitive.
It would be VERY nice if the database also had a cronology so that one could query the database for values that existed at the exact time that a specific line of code was run in the application, leading up to the bug.
You should try to use logging, e.g. commit logs from the DB and logging the user interactions with the application, if it is a web application you can start with the log files from the webserver. Make sure that the logfiles include all submitted data such as the complete GET url with parameters and POST with entity body. You can configure the web server to generate such logs when necesary.
Then you build a test client that can parse the log files and re-create all the user interaction that caused the problem to appear. If you suspect race conditions you should log with high precision (ms resolution) and make sure that the test client can run through the same sequences over and over again to stress those critical parts.
Replay (as your title suggests) is the best way to reproduce an error, just collect all the data needed to recreate the input that generated a specific state/situation. Do not focus on internal structures and return values, when it comes to hunting down an error or a bug you should not work in forensic mode, e.g. trying to analyse the cause of the crash by analyzing the wreck, you should crash the plane over and over again and add more and more logging/or use a debugger until you know that goes wrong.
We are trying to trace the time a windows default printer was changed and by who or what.
Any ideas?
I don't think that is tracked anywhere. For past changes, you might be out of luck.
For future changes, you could try setting up security auditing (via regedit: Permissions->Acvanced->Auditing) on HKCU\Software\Microsoft\Windows NT\CurrentVersion\Windows and watch for changes to that key in the Security event log. The amount of security event messages may make tracking difficult, though.