beacon | Simple observers for your code

I MUST maintain this line where she is.

That directive does not need to go inside the WordPress code block. You should place that directive before the # BEGIN WordPress comment marker. And this will prevent it from being overwritten by WordPress. In fact, you could place your custom rules at the very top of the file to make them easier to find/maintain.

It will work exactly the same.

You do not need to enclose it in an container like the other directives. And you should not repeat the RewriteEngine On and RewriteBase / directives. (The order of these particular directives do not matter. In fact, the last instance "wins" and controls the entire file.)

For example:

My tests show that iOS 15 successfully launching an app from a stopped state into the background on beacon region entry.

Test steps:

1. Install this app on my phone with iOS 14.8: https://github.com/davidgyoung/CoreLocationRegionLaunchDemo

2. Run the app, grant notification and location always permissions.

3. Go to settings and verify location permission is always

4. Turn on a beacon, verify an entry notification arrives. Then turn off the beacon, verify the exit notification arrives.

5. Reboot the phone. Wait 5 minutes. Turn on the beacon, then verify the entry notification arrives. Turn off the beacon and verify the exit notification arrives.

6. Upgrade to iOS 15.

7. Wait 5 mintues.

8. Turn on a beacon. Verify an entry notification arrives.

See screenshots -- sorry they are ugly, but I have to finish the giant download of XCode 13 before I can send screenshots directly to my computer.

The working logic of the Android side and the working logic of the ios side are different. On the Android side, we need to get a permission for every action related to the user. This is among google policies. There are different libraries developed for the location, but you need to add permissions in the same way. For example, another package you can use for location: https://github.com/mrmans0n/smart-location-lib or all : https://android-arsenal.com/tag/55

Library version 2.19+ introduces autowind APIs that make setting up beacon scanning much simpler, more intuitive and less prone to configuration errors.

In earlier versions of the library, auto-launch of an app on beacon detection was handled by the RegionBootstrap utility class, but as of 2.19 it is no longer necessary -- you simply start monitoring with startMonitoring(region). The library sample code shows an example of how to start up auto-launch section of the code samples

To start up beacon scanning in the background simply replace regionBootstrap = RegionBootstrap(this, region) with this:

Such a solution is possible with BLE beacons but has some implementation challenges. I have seen beacons used successfully in similar use cases like automatic workstation locking, contact tracing, virtual tethering of demo phones, and convention audience counting.

• BLE has a range of about 30-40 meters, longer with clear line of sight. If the Android devices is moved from one vehicle to another that are within 40 meters of each other, the original beacon will probably still be visible.

• You may be able to address the above issue with a "closest beacon" strategy, meaning that you consider whatever is seen as closest beacon above a certain signal threshold to be the vehicle the device is on or in.

• If you use a battery-powered beacon, you can mount it anywhere, but battery life will typically be limited to a year or less.

• A plugged-in beacon will never run out of power, but requires a USB supply, and AC outlet, or a DC supply like a car cigarette lighter port. This limits where you can hide it.

As you mention, there are other solutions aside from BLE like physical tether. But it is not inappropriate to consider BLE as it is widely used for similar proximity measurement applications.

You seem to be running your simulation in "release" mode, not "debug" mode. While this will let your simulation run much faster, it omits a lot of sanity checks and prints only minimal information about what is happening in your simulation. For all of these reasons, it is highly recommended to only run a simulation in "release" mode after it is completely finished.

For information on how to run a simulation in debug mode, see the Veins FAQ entry "How can I debug my OMNeT++ simulation models? How do I create a stack trace?" at http://veins.car2x.org/documentation/faq/

When running your simulation in debug mode, you should see a lot more log information that explains what is going on in the simulation. For example, the log output might look like this:

I looked at the Android rules and regulations page

According to Google documents, from Android 8 onwards, all applications that do not have a Google-approved signature will be removed from the background after a few minutes.

But the solutions:

1. The first solution is to run the application in debug mode
2. The second solution is to assign a signature to the application and send it to Google for approval

recommend:

1. The third solution is to remove the google play service application from the emulator or android phone

Launching an app based on beacon detection works well on iOS because beacon monitoring is built on top of the same CoreLocation framework functionality as geofence region monitoring. It works like this:

1. When your app registers a Region for monitoring, the operating system remembers your app and the region, adding this pair to an OS-level tracking list.
2. Whenever iOS senses a location change (lat/lon for CLCircularRegion monitoring or BLE advert packets for CLBeaconRegion monitoring), it compares the change against this tracking list.
3. If a change in state is detected, iOS checks if the app is running. If so, it calls the didEnter or didExit delegate methods as appropriate.
4. If the app is not running, it first launches the app into the background, calling the app delegate’s onCreate method. After didFinishLaunching returns, iOS checks if the region state change that triggered the launch is registered with CoreLocation. If so, it calls didEnter or didExit.

The sequence in step 4 is critical for making this work — if you re-start monitoring before the end of didFinishLaunching in your app delegate, you get the didEnter callback.

And, yes, this all works even after killing an app from the task switcher because iOS does not remove an app’s monitored regions when the app is killed. It is one of the few ways you can relaunch and app after that action.

If you are not seeing log lines consistent with the above, there may be an issue with your logging. Try setting breakpoints and you will see the calls made in the sequence I describe above.

See this page for Apple's description of how didFinishLaunching is called when a CoreLocation change launches the app. That page is specifically for the significant location change service, but the same mechanism applies to beacon monitoring:

If you start this service and your app is subsequently terminated, the system automatically relaunches the app into the background if a new event arrives. In such a case, the options dictionary passed to the application:willFinishLaunchingWithOptions: and application:didFinishLaunchingWithOptions: methods of your app delegate contains the key UIApplicationLaunchOptionsLocationKey to indicate that your app was launched because of a location event. Upon relaunch, you must still configure a location manager object and call this method to continue receiving location events. When you restart location services, the current event is delivered to your delegate immediately. In addition, the location property of your location manager object is populated with the most recent location object even before you start location services.

You don't show the definition of your Region objects, but I suspect they might look something like this: