according to the image below, is it fair to say that Eddystone-URL beacons cannot be associated with attachments((with google beacon platform, even if deprecated)) because it does not have an ID identifier in the frame? the UUID acts only at the GAP level of the protocol stack
enter image description here
The old Google Beacon Platform (for which Google announced a shut down date of April 1, 2021) included a registration endpoint which would allow you to register the beacon with their servers. One of the benefits of this server registration was to allow you to attach data on the server-side, so that when the beacons were detected by Google Play Services, the attachments would be downloaded and made available through the API.
This did work with Eddystone-URL, because the identifier payload used to register the beacon was simply a sequence of bytes. In the case of Eddystone-URL, you would register the bytes of the compressed URL (using Google's Eddystone-URL compression scheme). The registered bytes were Base64 encoded, so it didn't matter that they were binary data. You simply set the type to EDDYSTONE which covered both the typical EDDYSTONE-UID and less commonly registered EDDYSTONE-URL.
See here for more info on the way the AdvertiseId was registered.
Related
Since everything is on-chain in Ethereum blockchain. Theoretically, each event is public visible and can be summed up as a block event. Is it possible to subscribe to events of non-contract addresses and create a feed page like RSS subscription?
It is possible, but honestly, I have never seen integration with the RSS protocol.
However, writing your script in the programming language is very easy. The procedure is well documented in the official geth documentation: https://goethereumbook.org/event-subscribe/
I would use this as a reference for other languages.
There is one big problem for you. To subscribe to Ethereum, you need access to the Ethereum node to get events from it.
There are three options from the best to the worst (in my opinion).
You can use the API from parties that provide access to ethereum networks. Example of it is INFURA, Alchemy and QuickNode. The huge disadventage is that requests are limited and you will use it very fast. Probably in minutes or hours.
You can create your own node connected to the Ethereum, but you need pretty fast computer/stable internet and 1TB SSD hard drive to keep it stable.
Find publicly available node. Usualy those nodes are not very stable and you will get ban soon. To discover ethereum nodes you can use Shodan. I have tried houndred times to use the public nodes to write my apps and those nodes are not stable. Each stable node is protected and does not allow to send any request to it...
If you need to read data from specific addresses you can use the Etherscan API - I love it as it is much easier than using the ETH API :)
There is an opensource protocol named RSS3 dedicated to RSS service on blockchain.
Its third-party API accesses the Ethereum network and creates a feed of any ENS address. The protocol not only displays transactions of the ENS, but also identifies and filter different types of on-chain transactions.
(check how more on RSS3 Docs and its Github)
The feed can be generated to a standard XML format RSS file, or import the RSS URL or that address directly to any RSS reader.
Take ETH founder Vitalik's ENS address (vitalik.eth) for example.
Access RSS3.io and type in the ENS
enter vitalik.eth
Generate RSS file
Click the RSS icon on the right and get the RSS file:
https://rss3.io/rss/0xd8da6bf26964af9d7eed9e03e53415d37aa96045/
Generate RSS URL
Go to https://rss3.io/manage and generate an RSS feed for an address/ENS.
Type in Vitalik.eth and get different types of RSS feed subscription:
All feeds: https://rss3.io/rss/vitalik.eth
These URLs should work in any RSS reader.
Evernote client app for Windows desktop allows one to create the ink notes which are internally stored as note's resources with a particular mime type: application/vnd.evernote.ink. The format of the resource is known to not be shared with the developer community and no official Evernote apps for non-Windows platforms support this particular way to create the handwritten notes; such clients represent the existing ink notes (created via the Windows client) by read-only images which are said to be possible to download from the Evernote server.
I was unable to find any further documentation or notes on how exactly to do this. The only source of knowledge available seems to be the source code of NixNote2, the unofficial open source Evernote client for Linux desktop. Here's the URL structure for such a request understood from the mentioned source code:
https://[service]/shard/[shardId]/res/[resourceGuid].ink?slice=[sliceNumber]
where [service] is the name of the Evernote service (either sandbox.evernote.com or www.evernote.com), [shardId] is the shard ID where the note is stored, [resourceGuid] is the GUID of the ink note's resource, the image for which one wishes to download via the request, [sliceNumber] is the number of the vertical stripe of the downloaded image i.e. the whole image is supposed to be downloaded via possibly more than one request.
My question is, how can one find out how many slices the ink note image might contain and hence, how many slices to request? In theory one can download the vertical stripes one by one until the cumulative height of the received slices reaches the height of the note image's resource but that would mean doing synchronous requests one by one which is not optimal performance-wise.
I also tried to do the request without the slices part at all. I do receive a reply for it but somehow the received data seems corrupt, I can't read a PNG image from it.
Is it possible to tell Amazon Echo (using SSML) to play an mp3 file from a specific offset?
It is not possible to do this using the current APIs. As shown in the documentation for the SSML tag, there is only one possible attribute which can be set on this tag, which is src. Note that there are also requirements and limitations to the source that can be specified:
src: Specifies the URL for the MP3 file. Note the following requirements
and limitations:
The MP3 must be hosted at an Internet-accessible HTTPS endpoint. HTTPS
is required, and the domain hosting the MP3 file must present a valid,
trusted SSL certificate. Self-signed certificates cannot be used.
The MP3 must not contain any customer-specific or other sensitive
information.
The MP3 must be a valid MP3 file (MPEG version 2).
The audio file cannot be longer than ninety (90) seconds.
The bit rate must be 48 kbps. Note that this bit rate gives a good result when used
with spoken content, but is generally not a high enough quality for
music. You may need to use converter software to convert your MP3
files to the required codec version (MPEG version 2) and bit rate (48
kbps). One option for this is FFmpeg.
It goes on to say this about using the audio tag:
Include the audio tag within your text-to-speech response within the
speak tag. Alexa plays the MP3 at the specified point within the text
to speech. For example:
<speak>
Welcome to Car-Fu. <audio src="https://carfu.com/audio/carfu-welcome.mp3" /> You can order a ride,
or request a fare estimate. Which will it be?
</speak>
As described in this example, the given mp3 will simply be played in its entirety at the given point in the dialog, with no other configuration available. To accomplish the functionality you're desiring, you would need to dynamically create a new MP3 beginning at your desired timestamp, which complies with the requirements in the first block quote, and serve that file with your response.
I confirm, self-signed certificates cannot be used. I have my skill server accessible in a publicly available address with self-signed certificates. Now I need to ask Amazon to play my mp3 file stored in that same machine and it forces me to change the certificates. I used letsencrypt and it works fine
I need to take a few RSS feeds, and archive all the items that get added to them. I've never consumed or created RSS before, but I know xml, so the format seems pretty intuitive.
I know how to parse the feed: How can I get started making a C# RSS Reader?
I know I can't rely on the feed server to provide a complete history: Is it possible to get RSS archive
I know I'll have to have some custom logic around duplicates: how to check uniqueness (non duplication) of a post in an rss feed
My question is, how can I ensure I don't miss any items? My initial plan is to write a parser, where for each item in the feed:
1) Check to see if it's already in the archive database
2) If not, add it to the database
If I schedule this to run once a day, can I be confident I won't be missing any items?
It depends on the feed, some sites publish articles very frequently and may have their RSS feed configured to show only the 10 most recent articles. Some sites are going to do the opposite.
Ideally your app should 'learn' the frequency this from the sites and tune itself to ping those sites based on the learnt frequency. (Ex: If you see new unique articles every time you ping, you'll need to ping more often, on the other hand if you see the same set of articles on multiple attempts, you may back off the next time).
If you're open to relying on a service for this... I built my own RSS archival service (https://app.pub.center). You can access an RSS feed's data via our API.
Page 1 of The Atlantic
https://pub.center/feed/02702624d8a4c825dde21af94e9169773454e0c3/articles?limit=10&page=1
Page 2 of The Atlantic
https://pub.center/feed/02702624d8a4c825dde21af94e9169773454e0c3/articles?limit=10&page=2
The REST API is free. We have pricing plans for push notifications (email, SMS, your custom API endpoint)
Use a series of decisions based on the feed and the storage limitations. For example:
Connect to the Web site, and download the XML source of the feed. The Feed Download Engine downloads feeds and enclosures via HTTP or Secure Hypertext Transfer Protocol (HTTPS) protocols only.
Transform the feed source into the Windows RSS Platform native format, which is based on RSS 2.0 with additional namespace extensions. (The native format is essentially a superset of all supported formats.) To do this, the Windows RSS Platform requires Microsoft XML (MSXML) 3.0 SP5 or later.
Merge new feed items with existing feed items in the feed store.
Purge older items from the feed store when the predetermined maximum number of items have been received.
Optionally, schedule downloads of enclosures with Background Intelligent Transfer Service (BITS).
Use HTTP to its fullest to minimize wasted bandwidth:
To limit its impact on servers, the Feed Download Engine implements HTTP conditional GET combined with Delta encoding in HTTP (RFC3229) World Wide Web link. This implementation allows the server to transfer a minimal description of changes instead of transferring an entirely new instance of a resource cached on the client. The engine also supports compression using the HTTP gzip support of Microsoft Win32 Internet (WinInet).
A successful synchronization means that the feed was successfully downloaded, verified, transformed into the native format, and merged into the store. A server response of HTTP 304 Not Modified in response to a HTTP conditional GET (If-Modified-Since, If-None-Match, ETag, and so on) also constitutes success.
And define criteria for removal:
The following properties directly affect the number of items that remain after a synchronization operation.
PubDate—used to determine the "age" of items. If PubDate is not set, LastDownloadTime is used. If the feed is a list, the order of items is predetermined and PubDate (if present) is ignored.
MaxItemCount—a per-feed setting that limits the number of archived items. The feed's ItemCount will never exceed the maximum, even if there are more items that could be downloaded from the feed.
ItemCountLimit—the upper limit of items for any one feed, normally defined as 2500. The value of MaxItemCount may not exceed this limit. Set MaxItemCount to ItemCountLimit to retain the highest possible number of items.
References
Understanding the Feed Download Engine
I have an application which stores data to the persistent store by setting the contents of the PersistentObject as a hashtable, e.g. saving preferences is done by entering strings as the keys and values of the hashtable and then setContents is called on the PersistentObject with the Hashtable passed as the parameter.
I understand that the data is saved unencrypted. If I enable content protection in the IT policy for the device will this implementation of persistent storage automatically start encrypting the data or do I have to change the implementation to use for example the ContentProtectedHashtable for saving the contents?
All the information I have found so far about content protection has been with regards to the BES IT policy and nothing about implementation in the application, which makes me think that the standard implementation (i.e. just commiting a Persistable object to PersistentObject object) is adapted automatically to encrypt the data??
Any ideas?? Thanks.
See the documentation for net.rim.device.api.util.ContentProtectedHashtable for one way to implement content protection.
Also see this document for a more in depth discussion of content protection.
I don't think it has something to do with IT policy, it's rather PersistentContent which has encryption/decryption functionality:
This API was designed to allow applications to protect data in a database if the user has enabled Content Protection/Compression in their device's security settings. It consists of two main methods (encode and decode), as well as a number of helper methods.
...
Note that encoding can be performed anytime, whether the device is locked or unlocked. However, an object that was encoded using encryption can only be decoded if the device is unlocked. This can pose a problem if the device locks while an application is performing a potentially long operation during which it requires the ability to decode encrypted data, such as sorting encrypted records. In this case, the application can obtain a ticket. So long as a strong reference to a ticket exists, decoding encrypted data is allowed. Thus, applications should release tickets as soon as possible to allow the device to reach a locked and secure state.
See riccomini - code blackberry persistent store for encryption implementation.