I am using GoogleFit HistoryAPI for get step data from user. It's working well.
However, in my case, I want to distinguish data between from different devices (using same account) because I don't want user using same account for 2 or more devices (it is a game base on step so I don't want user play on 1 device and have achievement on many devices).
I found that Device from DataSource#getDevice, Device#getLocalDevice can help me distinguish data between from different devices. Below is info from official docs:
To get information about the device for a data source, use the DataSource.getDevice method. The device information is useful to distinguish from similar sensors on different devices, show the device information from a sensor to the user, or process data differently depending on the device. For example, you may be interested in reading data specifically from the a sensor on a wearable device but not from the same type of sensor on the phone.
To get a Device instance for the device that is running your activity, use the Device.getLocalDevice static method. This is useful when you want to check if a data source is on the same device that your app is running on.
So,
// My idea is comparing the uid of local device and uid of device in datasource
// if it is same => step come from THIS device
// if not => step come from OTHER device
private void dumpDataSet(DataSet dataSet) {
for (DataPoint dp : dataSet.getDataPoints()) {
Log.i(Constant.TAG, "Origin type uid: " + dp.getOriginalDataSource().getDevice().getUid());
Log.i(Constant.TAG, "Local device uid: " + Device.getLocalDevice(getApplicationContext()).getUid());
...
}
}
However, the logcat result for datasource from only 1 DEVICE is
Origin type uid: 9ff67c48
Local device uid: f2b01c49ecd9c389
// Only the model, manufacturer is same (but I can not use 2 fields because user can use 2 devices with same model, manufacturer)
You can see that the uid from datasource is different to local device uid, so I can not distinguish data.
Is there any way to distinguish data between from different devices? Any help or suggestion would be great appreciated.
DEMO project
From what I get, I think you a looking ro stable ID for each Device. There are few ways of using ID, on which you can relay.
public static String getSerial() {
final String serial;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
serial = Build.getSerial();
} else {
serial = Build.SERIAL;
}
return serial;
}
As another eample, it's common to use IMEI, to relay on Unique ID, from Telephony Manager.
public static String getDeviceImei(Context ctx) {
TelephonyManager telephonyManager = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
return telephonyManager.getDeviceId();
}
And last, but maybe most correct way, I suggest to use Secure ID. Which provides stable background, of using this value. From the Doc On devices that have multiple users, each user appears as a completely separate device, so the ANDROID_ID value is unique to each user. Settings.Secure#ANDROID_ID
import android.provider.Settings.Secure;
private String android_id = Secure.getString(getContext().getContentResolver(),
Secure.ANDROID_ID);
I am designing a chat application with registered phone number for both iOS and android app.
I want to make sure that this number and app works on one phone at a time, as below scenarios given I want to make sure that app once authenticated to another device with same account details disable the previous device.
1) app installed on one iOS device registered account and deleted and reinstalled on same device again
2) app installed on iOS phone then same account is validated on android app the iOS phone app should show disabled account
3) app installed on two android phone with same number should disable old one automatically.
Reason is I don't want multiple copies of application with same number running to avoid like whatsapp does.
I am thinking of device keychain for iOS and android Mac Id usage to get this worked out since apple stopped UDID broadcasting to server.
Also have a vague Idea about this vendor id apple providing.
Can anyone advice on this. How can I achieve so app is running with same account on one phone only and other just stops.
If you are binding an app with a phone number getting registered then it can run only on one device since you can't have same ph number running on 1+ devices at the same time. From user's perspective if he is changing same number between multiple handsets, going by your case, this app is blocking previous device of user, it sounds like a never ending loop. Everytime user's previous device is getting blocked or it may result in blocking all user's device. Dosen't make sense to me at least.
Below method is for getting device ID
public static String getDeviceID(Context p_context) throws Throwable
{
String m_deviceID = null;
TelephonyManager m_telephonyManager = null;
m_telephonyManager = (TelephonyManager) p_context
.getSystemService(Context.TELEPHONY_SERVICE);
m_deviceID = m_telephonyManager.getDeviceId().toString();
if (m_deviceID == null || "00000000000000".equalsIgnoreCase(m_deviceID))
{
m_deviceID = "AAAAAAA";
}
return m_deviceID;
}
More information about the identification you can read here.
I want to create a p2p connection between a normal android WiFi device and another android device with WiFi direct support.
Am successfully able to create a group(uisng createGroup of WifiP2pManager) and using the SSID and pass phrase given by the android I am also successfully able to connect a normal WiFi device to my WiFi-direct enabled device( in which I created group using wifi direct apis).
But here android gives some random WiFi SSID and pass phrase , which results in me looking at the adb logs always for SSID name and then entering in the other device.
Is there anyway in which I can set the SSID and passphrase of my choice?
Thanks
Kozlov
requestGroupInfo() enables you to get both the SSID and passphrase, however, I don't think it's possible to adjust these (yet)..
Firstly, the best way would be not to change but only retrieve the WifiP2p settings and pass them you a connecting legacy device (one that does not support WifiP2p because only there you need a passphrase) using a different channel like bluetooth or NFC. A QR code may also work.
The previous Message showed you, how to get you SSID and Passphrase. The Passphrase can't be changed, however, the SSID can. The Wifi Direct spec settles the SSID to be "DIRECT__" where xy are some random generated letters during setup. So you cant change this prefix "DIRECT" and the two letters, because both the letters and passphrase are generated in internal libraries and only a read only copy is passed back to the application.
However you can change what comes afterwards the SSID prefix using reflection API.
private void openWifiDirectChannel(String name){
WifiP2pManager manager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
WifiP2pManager.Channel channel = manager.initialize(this, getMainLooper(), null);
//Use reflection API to get the hidden method for setting the P2P network name
try {
Method m = manager.getClass().getMethod(
"setDeviceName",
WifiP2pManager.Channel.class, String.class, WifiP2pManager.ActionListener.class );
m.invoke(manager, channel, name, new WifiP2pManager.ActionListener() {
public void onSuccess() {
//Code for Success in changing name
}
public void onFailure(int reason) {
//Code to be done while name change Fails
}
});
} catch (Exception e)
e.printStackTrace();
}
I want some unique ID of the Android device. I've tried it with the following code
String ts = Context.TELEPHONY_SERVICE;
TelephonyManager telephonyManager = (TelephonyManager) this.getSystemService(ts);
However I know that this works only for phones.
What if my app is running on some notebook, netbook or other type of device? How do I get an unique ID in that case?
There are three types of identifier on android phone.
IMEI
IMSI
String ts = Context.TELEPHONY_SERVICE;
TelephonyManager mTelephonyMgr = (TelephonyManager) getSystemService(ts);
String imsi = mTelephonyMgr.getSubscriberId();
String imei = mTelephonyMgr.getDeviceId();
Android ID
It is a 64-bit hex string which is generated on the device's first boot.
Generally it won't be changed unless is factory reset.
Secure.getString(getContentResolver(), Secure.ANDROID_ID);
Sorry to bump an old thread but this problem gives me headache, I found a good article for someone to read, and this really helps me a lot.
Sometimes it is required during Android application development to get the unique id of the Android based smartphone device. This is necessary in cases when the user wants to track the unique device installations of the application.
This is also useful in cases where the Android developer wants to send Push messages to only few specific devices. So over here it becomes necessary to have a UDID for every device.
In Android there are many alternatives to UDID of the device. Some of the methods to get the UDID in android application are listed below with its advantages and disadvantages and any necessary permissions for getting the device ID.
The IMEI: (International Mobile Equipment Identity)
The Android ID
The WLAN MAC Address string
The Bluetooth Address string
1) IMEI: (International Mobile Equipment Identity)
The IMEI Number is a very good and primary source to get the device ID. It is unique for each and every device and is dependent on the device Hardware. So it is also unique for each and every device and it is permanent till the lifetime of the device.
The code snippet to get the Device IMEI is as below,
TelephonyManager TelephonyMgr = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
String m_deviceId = TelephonyMgr.getDeviceId();
For this your application will require the permission “android.permission.READ_PHONE_STATE” given in the manifest file.
Advantages of using IMEI as Device ID:
The IMEI is unique for each and every device.
It remains unique for the device even if the application is re-installed or if the device is rooted or factory reset.
Disadvantages of using IMEI as Device ID:
IMEI is dependent on the Simcard slot of the device, so it is not possible to get the IMEI for the devices that do not use Simcard.
In Dual sim devices, we get 2 different IMEIs for the same device as it has 2 slots for simcard.
2) The Android ID
The Android_ID is a unique 64 bit number that is generated and stored when the device is first booted. The Android_ID is wiped out when the device is Factory reset and new one gets generated.
The code to get the Android_ID is shown below,
String m_androidId = Secure.getString(getContentResolver(), Secure.ANDROID_ID);
Advantages of using Android_ID as Device ID:
It is unique identifier for all type of devices (smart phones and tablets).
No need of any permission.
It will remain unique in all the devices and it works on phones without Simcard slot.
Disadvantages of using Android_ID as Device ID:
If Android OS version is upgraded by the user then this may get changed.
The ID gets changed if device is rooted or factory reset is done on the device.
Also there is a known problem with a Chinese manufacturer of android device that some devices have same Android_ID.
3) The WLAN MAC Address string
We can get the Unique ID for android phones using the WLAN MAC address also. The MAC address is unique for all devices and it works for all kinds of devices.
The code snippet to get the WLAN MAC address for a device is as shown below,
WifiManager m_wm = (WifiManager)getSystemService(Context.WIFI_SERVICE);
String m_wlanMacAdd = m_wm.getConnectionInfo().getMacAddress();
Your application will require the permission “android.permission.ACCESS_WIFI_STATE” given in the manifest file.
Advantages of using WLAN MAC address as Device ID:
It is unique identifier for all type of devices (smart phones and tablets).
It remains unique if the application is reinstalled.
Disadvantages of using WLAN MAC address as Device ID:
If device doesn’t have wifi hardware then you get null MAC address, but generally it is seen that most of the Android devices have wifi hardware and there are hardly few devices in the market with no wifi hardware.
4) The Bluetooth Address string
We can get the Unique ID for android phones using the Bluetooth device also. The Bluetooth device address is unique for each device having Bluetooth hardware.
The code snippet to get the Bluetooth device address is as given below,
BluetoothAdapter m_BluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
String m_bluetoothAdd = m_BluetoothAdapter.getAddress();
To get the above code, your application needs the permission “android.permission.BLUETOOTH” given in the manifest file.
Advantages of using Bluetooth device address as Device ID:
It is unique identifier for all type of devices (smart phones and tablets).
There is generally a single Bluetooth hardware in all devices and it doesn’t gets changed.
Disadvantages of using Bluetooth device address as Device ID:
If device hasn’t bluetooth hardware then you get null.
As per me these are few of the best possible ways to get the Unique Device ID for Android smartphone device and their pros and cons of using it. Now it is upto you to decide which method to use based on the Android application development requirements.
If there are any other methods to get UDID and that covers up the disadvantages of above methods, then I would love to explore those in my Android application. Pl. share those in comment box and also if any suggestions or queries.
Here's the article
Secure.getString(getContentResolver(), Secure.ANDROID_ID);
This will not work for all the devices.
Some of the android devices has a problem Some devices returns null when we try to get the Device ID.The only way to solve this issue is to make a pseudodeviceID which should be generated by ourself.This function will generation a unique device ID for you.You can make changes to this function as you needed.Me too struggled a lot for solving this issue.
public String getDeviceID() {
/*String Return_DeviceID = USERNAME_and_PASSWORD.getString(DeviceID_key,"Guest");
return Return_DeviceID;*/
TelephonyManager TelephonyMgr = (TelephonyManager) getApplicationContext().getApplicationContext().getSystemService(Context.TELEPHONY_SERVICE);
String m_szImei = TelephonyMgr.getDeviceId(); // Requires
// READ_PHONE_STATE
// 2 compute DEVICE ID
String m_szDevIDShort = "35"
+ // we make this look like a valid IMEI
Build.BOARD.length() % 10 + Build.BRAND.length() % 10
+ Build.CPU_ABI.length() % 10 + Build.DEVICE.length() % 10
+ Build.DISPLAY.length() % 10 + Build.HOST.length() % 10
+ Build.ID.length() % 10 + Build.MANUFACTURER.length() % 10
+ Build.MODEL.length() % 10 + Build.PRODUCT.length() % 10
+ Build.TAGS.length() % 10 + Build.TYPE.length() % 10
+ Build.USER.length() % 10; // 13 digits
// 3 android ID - unreliable
String m_szAndroidID = Secure.getString(getContentResolver(),Secure.ANDROID_ID);
// 4 wifi manager, read MAC address - requires
// android.permission.ACCESS_WIFI_STATE or comes as null
WifiManager wm = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
String m_szWLANMAC = wm.getConnectionInfo().getMacAddress();
// 5 Bluetooth MAC address android.permission.BLUETOOTH required
BluetoothAdapter m_BluetoothAdapter = null; // Local Bluetooth adapter
m_BluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
String m_szBTMAC = m_BluetoothAdapter.getAddress();
System.out.println("m_szBTMAC "+m_szBTMAC);
// 6 SUM THE IDs
String m_szLongID = m_szImei + m_szDevIDShort + m_szAndroidID+ m_szWLANMAC + m_szBTMAC;
System.out.println("m_szLongID "+m_szLongID);
MessageDigest m = null;
try {
m = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
m.update(m_szLongID.getBytes(), 0, m_szLongID.length());
byte p_md5Data[] = m.digest();
String m_szUniqueID = new String();
for (int i = 0; i < p_md5Data.length; i++) {
int b = (0xFF & p_md5Data[i]);
// if it is a single digit, make sure it have 0 in front (proper
// padding)
if (b <= 0xF)
m_szUniqueID += "0";
// add number to string
m_szUniqueID += Integer.toHexString(b);
}
m_szUniqueID = m_szUniqueID.toUpperCase();
Log.i("-------------DeviceID------------", m_szUniqueID);
Log.d("DeviceIdCheck", "DeviceId that generated MPreferenceActivity:"+m_szUniqueID);
return m_szUniqueID;
}
Look at the constant
ANDROID_ID in android.provider.Secure.Settings to see if that helps.
I am adding a few useful links from official docs;
Best Practices for Unique Identifiers
Changes to Device Identifiers in Android O
For detailed instructions on how to get a Unique Identifier for each Android device your application is installed from, see this official Android Developers Blog posting:
http://android-developers.blogspot.com/2011/03/identifying-app-installations.html
It seems the best way is for you to generate one your self upon installation and subsequently read it when the application is re-launched.
I personally find this acceptable but not ideal. No one identifier provided by Android works in all instances as most are dependent on the phone's radio states (wifi on/off, cellular on/off, bluetooth on/off). The others like Settings.Secure.ANDROID_ID must be implemented by the manufacturer and are not guaranteed to be unique.
The following is an example of writing data to an INSTALLATION file that would be stored along with any other data the application saves locally.
public class Installation {
private static String sID = null;
private static final String INSTALLATION = "INSTALLATION";
public synchronized static String id(Context context) {
if (sID == null) {
File installation = new File(context.getFilesDir(), INSTALLATION);
try {
if (!installation.exists())
writeInstallationFile(installation);
sID = readInstallationFile(installation);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return sID;
}
private static String readInstallationFile(File installation) throws IOException {
RandomAccessFile f = new RandomAccessFile(installation, "r");
byte[] bytes = new byte[(int) f.length()];
f.readFully(bytes);
f.close();
return new String(bytes);
}
private static void writeInstallationFile(File installation) throws IOException {
FileOutputStream out = new FileOutputStream(installation);
String id = UUID.randomUUID().toString();
out.write(id.getBytes());
out.close();
}
}
Use a MAC address:
A Media Access Control address (MAC
address) is a unique identifier
assigned to network interfaces
Any device connected to a network is guaranteed to have a MAC address, and you can find it on the Android by going to Settings > About Phone > Status.
You should be able to get the bluetooth Mac address using the Bluetooth API.
You can try this:
String deviceId = Secure.getString(this.getContentResolver(),
Secure.ANDROID_ID);
Settings.Secure#ANDROID_ID returns the Android ID as an unique 64-bit hex string.
import android.provider.Settings.Secure;
private String android_id = Secure.getString(getContext().getContentResolver(),
Secure.ANDROID_ID);
final TelephonyManager tm = (TelephonyManager) getBaseContext().getSystemService(Context.TELEPHONY_SERVICE);
final String tmDevice, tmSerial, tmPhone, androidId;
tmDevice = "" + tm.getDeviceId();
tmSerial = "" + tm.getSimSerialNumber();
androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
UUID deviceUuid = new UUID(androidId.hashCode(), ((<span id="IL_AD3" class="IL_AD">long</span>)tmDevice.hashCode() << 32) | tmSerial.hashCode());
String deviceId = deviceUuid.toString();
You can get MAC address if network-device (Bluetooth etc.) is enabled in the system (turned on). But device may have Bluetooth, WiFi, etc. or nothing.
You may write your own unique ID generator (with 20 numbers or symbols randomly for example)
TextView textAndroidId = (TextView)findViewById(R.id.androidid);
String AndroidId = Settings.Secure.getString(getContentResolver(), Settings.Secure.ANDROID_ID);
textAndroidId.setText("My ID is: " + AndroidId);
Since new restrictions have been applied to the MAC address and other telephony-related API's and one can only access those hardware-related Unique identifiers if they are part of the system app and has the required privileges.
from docs:
When working with Android identifiers, follow these best practices:
Avoid using hardware identifiers. In most use cases, you can avoid using hardware identifiers, such as SSAID (Android ID), without limiting required functionality.
Android 10 (API level 29) adds restrictions for non-resettable identifiers, which include both IMEI and serial number. Your app must be a device or profile owner app, have special carrier permissions, or have the READ_PRIVILEGED_PHONE_STATE privileged permission in order to access these identifiers.
Only use an Advertising ID for user profiling or ads use cases. When using an Advertising ID, always respect users' selections regarding ad tracking. Also, ensure that the identifier cannot be connected to personally identifiable information (PII), and avoid bridging Advertising ID resets.
Use a Firebase installation ID (FID) or a privately stored GUID whenever possible for all other use cases, except for payment fraud prevention and telephony. For the vast majority of non-ads use cases, an FID or GUID should be sufficient.
Use APIs that are appropriate for your use case to minimize privacy risk. Use the DRM API for high-value content protection and the SafetyNet APIs for abuse protection. The SafetyNet APIs are the easiest way to determine whether a device is genuine without incurring privacy risk.
The remaining sections of this guide elaborate on these rules in the context of developing Android apps.
The best case is we use the FID or GUID to identify the uniqueness of the app per installation, here is how you can do it.
fun getDeviceId(): String {
return FirebaseInstallations.getInstance().id.result ?: UUID.randomUUID().toString()
}
You can check permission and can evaluate the value it will give you the device id:
private static final int REQUEST_READ_PHONE_STATE = 1;
int permissionCheck = ContextCompat.checkSelfPermission(getContext(),
Manifest.permission.READ_PHONE_STATE);
if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.READ_PHONE_STATE}, REQUEST_READ_PHONE_STATE);
} else {
TelephonyManager tManager = (TelephonyManager) getContext().getSystemService(Context.TELEPHONY_SERVICE);
String uid = tManager.getDeviceId();
System.out.print(uid);
}
Output: 358240051111110
This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
Determine if running on a rooted device
How do you determine (programmatically) if an Android device is: rooted Running a cracked copy of your software or rom.
I have some sensitive information in my database, and I would like to encrypt it when the phone is rooted aka the user has access to the database. How do I detect that?
Rooting detection is a cat and mouse game and it is hard to make rooting detection that will work on all devices for all cases.
See Android Root Beer https://github.com/scottyab/rootbeer for advanced root detection which also uses JNI and native CPP code compiled into .so native library.
If you need some simple and basic rooting detection check the code below:
/**
* Checks if the device is rooted.
*
* #return <code>true</code> if the device is rooted, <code>false</code> otherwise.
*/
public static boolean isRooted() {
// get from build info
String buildTags = android.os.Build.TAGS;
if (buildTags != null && buildTags.contains("test-keys")) {
return true;
}
// check if /system/app/Superuser.apk is present
try {
File file = new File("/system/app/Superuser.apk");
if (file.exists()) {
return true;
}
} catch (Exception e1) {
// ignore
}
// try executing commands
return canExecuteCommand("/system/xbin/which su")
|| canExecuteCommand("/system/bin/which su") || canExecuteCommand("which su");
}
// executes a command on the system
private static boolean canExecuteCommand(String command) {
boolean executedSuccesfully;
try {
Runtime.getRuntime().exec(command);
executedSuccesfully = true;
} catch (Exception e) {
executedSuccesfully = false;
}
return executedSuccesfully;
}
Probably not always correct. Tested on ~10 devices in 2014.
If the information is sensitive you should probably just encrypt it for all users. Otherwise a user could install your app unrooted, then root and read your database once the data's been written.
The official licensing guide says:
A limitation of the legacy
copy-protection mechanism on Android
Market is that applications using it
can be installed only on compatible
devices that provide a secure internal
storage environment. For example, a
copy-protected application cannot be
downloaded from Market to a device
that provides root access, and the
application cannot be installed to a
device's SD card.
It seems that you would benefit from using that legacy cop-protection to prevent your application from being installed on rooted devices.
You might release a separate version that can be installed on rooted devices with an encrypted database.