Can I use MachineID.getBytes() or MachineID.getUniqueID() as a unique identifier?

Question

The bytes from MachineID.getBytes() are not to be treated as a unique identifier for a device.  It is unique, but is volatile and not suitable to be used as an identifier.  There are various system/hardware events which can cause the MachineID bytes to change over time.  The same rule applies to MachineID.getUniqueID().  If you do .getBytes() and then compare that to AnotherMachineID.getBytes(), even though they can be the same device (but different runtime or browser), you will get a "false" if you're doing a direct byte-by-byte comparison.  This is because during the device individualization process, the device's hardware attributes are interrogated to get a hardware "fingerprint" of the device.  This is stored as a data structure in the MachineID data structure.
The only resilient way (with limtiations, as stated in the next section) to compare to different devices to determine if they are the same device is to use MachineID.matches().  That comparison is resilient against machine hardware upgrades (changing hard drives, upgrading your video card, upgrading your CPU, reformatting your machine, changing user accounts, using different browsers, etc…). 
(NOTE): There are 2 known limitations to using MachineID.matches():
1. MachineID in the Chrome browser (on any platform) a randomly-generated ID string that is not tied to the hardware.  The reason for this is that with the release of Chrome Version 28 browser introduced a sandbox, where code in the browser is not allowed to communicate directly with the hardware layer. This will cause .matches() to fail if comparing a MachineID from Chrome against a MachineID from Firefox, even from the same machine.  This also means that if a user "resets Adobe Access DRM/Licenses", they will lose their ID, and it will be re-generated (as a new ID) the next time DRM content is consumed and their machine has to create a new MachineID.
2. A similar limitation applies to iOS devices running iOS7 and higher, as a sandbox was also introduced to that platform, preventing applications from directly accessing the hardware.  If you are using iOS7 with a the Primetime Player SDK (PSDK) 1.0 or 1.1, the MachineID for all devices will be the same value, as Apple blocked the device-access APIs (which Adobe Access uses) and caused them to return a static string.  Since all iOS7 devices will return the same string when the device hardware interrogation happens, all iOS7 devices using the the PSDK 1.1 or earlier will return true when MachineID.matches() is called.  Adobe is working on a high-priority fix to this issue, which will be released in a PSDK 1.1 patch/hotfix, where another persistent API is used to bind the MachineID to the device, instead of the blocked device-access APIs.  This new binding mechanism will be persistent across application uninstall/re-installs.
What is consistent between iOS7 and Chrome 28 (and higher), is that the MachineID will no longer be tied to the hardware attributes of the device.
cheers,
/Eric.

Answer 1

In case you would like to find some way to do something that requires concurrency monitoring (e.g. You run a service and wish to limit the # of devices that can access a your service), the best way to do this would be to move towards a "# of concurrent streams" model, similar to Netflix.
To do this, you can use Adobe Pass technology called Mai Tai, or implement your own technology (via cookies or authentication tokens) to limit user accounts to no more than XX concurrent streams.
cheers,
/Eric.