This Policy explains what data the D-Konnect application processes, why, who receives it, and what rights you have. It applies to every distribution channel (app stores and direct APK installation), but the set of third-party components differs between them: the Google Play build carries two components more — a second recipient of crash reports and Google Play’s billing library. Appendix A lists the full set and says which channel each component runs in.
Summary
- The app requires no account and no registration. We do not ask for your name, e-mail or phone number, and we do not create a server-side user profile.
- Your data stays on your device. Vehicle readings, settings, indicators, formulas and measurement history are stored only on your device and are never sent to us. A profile, indicator or configuration leaves the device only when you share it yourself — as a file or through a short link (section 5, “Files and short links”); vehicle readings and history are never part of it.
- The app does not collect or store your geographic coordinates. The location permission is used to obtain speed and altitude from the system for the corresponding indicators.
- What does leave the device is anonymous technical telemetry (crash reports and usage statistics) and the data required by the ad network. Both are present in every build of the app, whichever channel you installed it from. If you installed from Google Play, one further service also receives crash reports — Firebase Crashlytics, by Google; the RuStore and direct-APK builds do not contain it (Appendix A).
- Personalised ads can be switched off inside the app — Settings → Privacy. Where the law requires consent to be obtained in advance (the EEA, the United Kingdom, Switzerland) the switch starts off, and turning it on is what gives that consent; elsewhere it starts on and can be turned off at any moment. Ads are shown either way: the switch decides how they are chosen, not whether they appear (section 5).
- We do not sell user data and do not share it with third parties for their own independent use, other than as described in sections 5 and 6.
Data processed and kept on your device
The following is stored in the app’s local databases and preference files. We have no access to it: it is sent neither to us nor to third parties.
| Category | What it is | Why |
|---|---|---|
| Vehicle profiles | profile name and description, the vehicle’s make and model if you entered them, and its set of indicators | keeping settings separate per vehicle |
| Indicators and formulas | custom and predefined indicators, units, conversion formulas, OBD request (PID) configurations | rendering readings on the dashboard |
| Connection (source) configurations | adapter initialisation command sequences (e.g. ATZ, ATE0, ATSP0) | correct handshake with a specific adapter |
| Vehicle data | values received from the OBD-II adapter (RPM, temperature, voltage, etc.) and values computed by your formulas | display and charting |
| Measurement history | a timestamped log of readings, errors and no-data markers; bounded in size, with the oldest rows removed automatically | charts, diagnostics, reviewing past trips |
| Known adapters | MAC address and display name of Bluetooth adapters you have connected to | quick reconnection and the known-devices list |
| App settings | interface and behaviour preferences | remembering your choices |
| Import records | a checksum of what the last import of each indicator and configuration brought | telling your own edits from a newer version when the same item is imported again |
The VIN and control-unit identifiers. The app asks the vehicle for its VIN on its own — one request per connection — and shows it on the connection status screen, where there is also a button to ask for it again. The value is held in memory for as long as the app is running: it is not written to the database, not included in backup, and never enters the measurement history.
Neither the VIN nor any other control-unit identifier is ever sent to the services in Appendix A — not in crash reports and not in usage statistics; the prohibition is enforced in the app’s own code. The technical logs record how much the vehicle answered, never what it answered.
If you create an indicator that reads the VIN or another control-unit identifier, that value is processed like any other reading — which means that, unlike the above, it is stored locally and written to the measurement history.
Deletion. All of the above is removed when the app is uninstalled, and also via the system “Clear data” function (Settings → Apps → D-Konnect → Storage). Individual items (profiles, indicators, known adapters, history) can be deleted inside the app.
Device permissions and why they are needed
Permissions are requested only when needed, with the reason shown at the time of the request.
| Permission | Purpose | If denied |
|---|---|---|
Bluetooth scan (BLUETOOTH_SCAN) | discover a nearby OBD-II adapter. Declared with the neverForLocation flag — the app does not derive location from Bluetooth scan results | a new adapter cannot be discovered |
Bluetooth connect (BLUETOOTH_CONNECT) | connect to the selected adapter and read its name | the adapter cannot be connected |
Location, approximate and precise (ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION) | obtain speed and altitude from the system for the corresponding indicators. Coordinates are not stored, not displayed and not transmitted | the speed and altitude indicators do not work; everything else keeps working |
Foreground service (FOREGROUND_SERVICE with the location and connectedDevice types) | keep reading from the adapter and recording history while the screen is off or the app is in the background — that is, during a drive | recording stops when the app is backgrounded |
Notifications (POST_NOTIFICATIONS) | show the mandatory notice that background recording is active | Android may restrict background work; recording becomes less reliable |
Beyond those, the app declares service permissions. They are never requested separately and show no dialog, but they appear in the permission list on the app’s store page:
| Permission | Purpose |
|---|---|
Internet and network state (INTERNET, ACCESS_NETWORK_STATE) | sending the data listed in section 4, loading ads, and creating short links and fetching files by them (section 5). Vehicle data is never sent over the internet: the adapter link is Bluetooth |
Advertising identifier (com.google.android.gms.permission.AD_ID) | declared by the ad SDK. The identifier itself is read only while personalised ads are switched on (section 5) |
Install source (BIND_GET_INSTALL_REFERRER_SERVICE and its RuStore counterpart) | install attribution by the ad SDK — see section 4 — and opening the short link whose page the app was installed from (section 5, “Installing from a link’s page”) |
In-app billing (com.android.vending.BILLING), Google Play build only | declared by Google Play’s billing library, which handles purchases through Google Play. The app offers no paid features yet, so no purchase can be started (section 6) |
Run at startup (RECEIVE_BOOT_COMPLETED) | declared by RuStore’s libraries — the metrics module that comes with RuStore’s payments SDK in every build, and, in the RuStore build, the SDK Install Referrer — so that their background jobs survive a reboot. The app does not enable the SDK Install Referrer’s jobs that send events to VK Ads and run VKR analytics (section 5, “Installing from a link’s page”); the app itself starts nothing when the device boots |
Any permission in the first table can be revoked in Android system settings at any time.
Data collected automatically while you use the app
The app processes operational data on the device and, to the extent described below, sends part of it to third-party services:
- Crash reports: device make and model, OS version, app version, stack trace and crash time. A report may carry a short technical trail of recent in-app actions; the same limits that apply to the events below apply to it — it can contain no vehicle readings, no coordinates and no text you have typed. In an app installed from Google Play, one and the same report goes to two recipients — AppMetrica and Firebase Crashlytics; in the other channels, to AppMetrica alone (Appendix A).
- Usage statistics: app launches and session duration, which feed audience metrics (active users, retention), together with events describing how the app performs for you: which screen is open; the answer to the Bluetooth permission prompt; the course of discovering and connecting an adapter — how many devices were found, whether the connection succeeded, how long it took, which known family the adapter belongs to and why a link dropped; the outcome of the handshake with the vehicle; whether fault codes were read or cleared and how many there were; an indicator added from the catalogue; the length of a search query and the number of rows it found; sharing and taking in files (section 5, “Files and short links”) — what kind of content was shared and how — as a link, by sending the file or by saving it — and, where a link could not be made, which of the reasons it was: a file too large, the server refusing it, no connection, or an answer that did not check out; how many profiles, indicators and configurations the file held, whether a file or a link was read, how many of its items were new, unchanged, changed or refused, how many were taken in, whether the free allowance held the import back, and which of these steps failed; ads served and shown.
- What these events never contain. The limit is enforced in the app’s own code: an event parameter may only be a number, a duration or a value from a closed list. Never sent: the VIN and other control-unit identifiers; the MAC address and the adapter’s name — the name is reduced on the device to a family such as
elm327or to an “unnamed” marker; coordinates, speed and altitude; any vehicle reading; text you have typed — the names of profiles, indicators and formulas, and the content of search queries. An indicator you wrote is reported ascustom, with neither its identifier nor its name. - Identifiers: third-party SDKs generate their own installation identifier, and use the device advertising identifier only while personalised ads are switched on (section 5). The installation identifier is reset on reinstall and is not linked to your identity.
- Install source: the store the app was installed from (Google Play, RuStore, direct APK). The app asks the system for it and reports it as a property of the installation. Separately from that, the ad SDK reads the details of the ad an install came from (Play Install Referrer and its RuStore counterpart); this attribution happens only while personalised ads are switched on (section 5).
The legal basis for this processing is the developer’s legitimate interest in keeping the app functional and stable (see section 8). There is no in-app toggle for crash reports and usage statistics; this collection stops when the app is uninstalled. Use of the advertising identifier for personalised advertising is a separate question with its own control — see section 5.
Third-party services
The set of third-party components depends on the channel the app was installed from: the Google Play build has three more, the RuStore build one more. The full list, with links to each provider’s policy, is in Appendix A, which also says which channel each component runs in. We pass these services only the data listed in section 4 and Appendix A; each provider processes it under its own policy.
Categories of services used:
- Crash reporting and technical diagnostics — required to ship stable updates.
- Aggregated usage analytics — audience-level metrics only.
- Advertising network — present in every build of the app. An ad network may process the advertising identifier, device information and approximate location derived from the IP address in order to select and count impressions. What it is allowed to use for that depends on your choice — see “Personalised ads and your choice” below. Ads are never shown on the dashboard screen while driving.
- App store payment processing — if purchases are available in your build (section 6).
- The short-link server and storage — see “Files and short links” below.
Personalised ads and your choice
The app shows no consent dialog. The starting position of the setting is decided by the jurisdiction the device appears to be in, and you can change it at any time.
How the starting position is decided. The app makes no network request to establish this: it reads the country of the SIM card, the country of the mobile network, the region of the device’s own language setting and the region of the device time zone. If any of them points to the European Economic Area, the United Kingdom or Switzerland — or if none of them answers at all — the app starts with personalisation off. Everywhere else it starts on. These signals are read on the device and are not transmitted or stored.
The control. Settings → Privacy → “Personalised ads”. It can be moved in either direction, as many times as you like: withdrawing is exactly as easy as giving. Your choice and the date you made it are kept on the device: neither we nor the ad network receive them. Android may include them in system backup along with your other settings — deliberately, so that a refusal of personalisation is not lost when you move to a new device (section 7).
What “off” means. The ad SDK is instructed not to use the advertising identifier and not to carry out install and attribution reporting. Ads are still shown, selected without those signals. The same choice reaches AppMetrica, the crash-reporting and analytics service of section 4, which then collects no advertising identifier either — the switch is not limited to the ad network. Firebase Crashlytics, in the Google Play build, collects the advertising identifier under no position of the switch: advertising-signal collection is disabled in the build itself and is never turned on.
Location sits outside the switch. The ad SDK is barred from reading the device location under either position of the switch: the bar is set in the build itself and is never lifted. Geographic coordinates do not leave the device whatever you choose, and whether or not the system location permission has been granted (section 3). The approximate location the ad network derives from the IP address of the request is not covered by that bar — it is computed on their side and is not the device’s coordinates.
What “off” does not stop is crash reporting itself and the aggregated audience metrics: those stand on a different basis, have no in-app toggle, and once the switch is off they carry no advertising identifier.
Independently of this setting, Android’s own settings let you reset or delete the advertising identifier for every app at once (“Privacy” → “Ads”).
AppMetrica serves two purposes at once
The Yandex Mobile Ads SDK ships together with the AppMetrica library, which therefore enters the app as a dependency of the ad SDK. The app also activates AppMetrica with its own key and uses it as its crash reporting and audience metrics service (section 4). Both are true in every channel: AppMetrica carries the analytics and receives crash reports everywhere, Google Play included — where it has a neighbour at the second task.
So the same library serves two purposes in parallel: the ad SDK’s own technical needs, under Yandex’s key, and ours, under the app’s key. It is listed once in Appendix A and the data column covers both.
Files and short links
A profile, an indicator or a connection configuration can be passed to another person as a .dkonnect file or as a link of the form https://dkonnect.denis55ka.app/s/…. This only ever happens on your action — the “Share” button, or opening a file or a link.
What is passed. Only what you chose: the profile’s name and description, the vehicle’s make and model if entered, the profile layout; indicators — names, units, formulas, ranges and request parameters; connection configurations with their commands. Never included: vehicle readings and measurement history, the VIN and other control-unit identifiers, adapters and their MAC addresses, location, app settings. Names and descriptions are your own text: before sending, make sure they hold nothing you do not want to share.
As a file. The file is made on the device and goes only where you send or save it — the app or folder you choose. The developer does not receive it; from there it is handled by the app you sent it with, under that app’s rules. The temporary copy made for sending sits in the app’s private directory and is replaced by the next one.
Opening a link. The app takes nothing from a link but its short identifier, and uses it to fetch the file from dkonnect.denis55ka.app — the developer’s static storage in Yandex Object Storage (Yandex.Cloud LLC, servers in Russia). The request carries no installation, device or advertising identifier: the provider sees only the IP address and the routine headers of the network library, which no HTTPS download goes without. The developer keeps no access logs for that storage; the provider processes the technical data of the request under its own terms (Appendix A). The link’s page that a browser opens is static: no counters, cookies or third-party scripts.
Creating a link. On a tap of “Send link”, the app sends the content described above to the developer’s server at api.dkonnect.denis55ka.app (Yandex Cloud: API Gateway and Serverless Containers, Yandex.Cloud LLC, servers in Russia). The server checks that it is a .dkonnect file and publishes it to the same storage. Before the tap, the app warns of what follows:
- the published content becomes public: anyone who has the link can open it;
- identical content gets one and the same link for everyone who shared it, and there are no accounts, so a link cannot be deleted from the app — it is kept indefinitely and taken down on request to the address in section 15;
- the request carries no installation, device or advertising identifier; the server keeps no request logs, the developer does not keep the sender’s IP address or anything else about the sender, and the content is linked neither to the device nor to an installation identifier; the provider processes the technical data of the request under its own terms (Appendix A);
- if a link cannot be created, the app offers to share a file instead.
Installing from a link’s page. The Google Play and RuStore buttons on a short link’s page pass the link’s identifier to the store — the same one that is visible in the link itself — and the store keeps it as the install source. On its first launch the app asks its store for the install source once: through Google Play Install Referrer Library in the Google Play build, and through RuStore’s SDK Install Referrer in the RuStore build. Both get their answer from the store’s app on your device. If the source is a link’s identifier, the app opens that link as if you had tapped it yourself, and nothing is imported without your confirmation. The app itself uses the store’s answer for nothing else: it sends it nowhere and keeps it only on the device, so as not to ask the store again. If the app was not installed from a link’s page, it opens nothing.
In the RuStore build, RuStore’s SDK Install Referrer itself sends service events about its own work to RuStore’s servers on such a request: that the install source was asked for, and that it was received. With them go the install source it received (the link’s identifier), the app’s package name and version, the SDK’s name and version, the time of the event and a random identifier that the SDK generates itself and keeps on the device. This is how the SDK is built: the app cannot switch it off. The service events are sent on every such request, including when the app was not installed from a link’s page — then without a link’s identifier. The SDK’s other functions — sending events to VK Ads (with a phone number and the advertising identifier) and VKR analytics — the app neither enables nor calls.
In-app purchases
If your build offers paid features, payment is processed by the app store the app was installed from. Card details are entered in the store’s own interface: the developer does not receive, see or store them. The app receives only the fact that a purchase exists, in order to unlock the paid features. Refunds and payment disputes are governed by the rules of that store.
The app does not offer paid features yet. The Google Play build already contains Google Play’s billing library (Appendix A), but no purchase can be started in it.
Backup and transfer to a new device
Android may include app data in system backup and in device-to-device transfer. The backup contains settings and configuration only: profiles, indicators, formulas, connection configurations, the list of known adapters (including their MAC addresses), app preferences and your personalised-ads choice (section 5) — the last of these is included deliberately, so that a refusal of personalisation is not reset on a new device. Measurement history is excluded from backup.
The backup is handled by your device’s system backup service, not by the developer. Backup can be disabled in Android system settings.
Legal bases and applicable law
This Policy is written to satisfy the law of the jurisdictions the app is distributed in, in particular:
- Russian Federation: Federal Law No. 152-FZ of 27 July 2006 “On Personal Data”. No personal data is processed on the developer’s servers: the developer’s infrastructure is the storage for short-link files and the server that publishes them on the user’s tap, in Yandex Cloud, in Russia, for which no request logs are kept (section 5); local data is processed on the user’s device.
- EEA, United Kingdom and Switzerland: Regulation (EU) 2016/679 (GDPR) and the equivalent UK and Swiss rules. Legal bases: consent — for location access and Bluetooth access (given through the system permission dialog) and for personalised advertising (given by turning on the switch described in section 5, which starts off in these countries, so no personalisation takes place until you act); legitimate interest — for crash diagnostics and aggregated statistics needed to keep the app working; performance of a contract — for providing the app’s functionality and any purchased features, including fetching the file behind a link you opened and publishing what you share by link.
- United States (California and states with comparable laws): these give you the right to opt out of the “sale” or “sharing” of personal information for targeted advertising. The switch in Settings → Privacy is that opt-out. We do not exchange user data for money.
The third-party services listed in Appendix A may process data outside your country; such transfers take place under those providers’ own terms.
Retention
- Local data is kept for as long as the app is installed and you have not deleted it; the measurement history is additionally bounded in size, and the oldest records are pruned automatically.
- Content published by short link is kept indefinitely, until it is taken down on request (section 5, “Files and short links”).
- Crash reports and statistics are retained by the service providers for the periods set in their policies (typically from several months to about 18 months).
- Correspondence with the developer is kept for as long as it is needed to answer you and resolve your question, and is deleted at your request at any time (section 15).
Your rights
You may:
- be informed about what data is processed — this Policy is the complete list;
- delete your data — through in-app functions, through the system “Clear data” action, or by uninstalling the app; local deletion is complete and irreversible;
- take down content published by short link — by writing to the address in section 15 with that link;
- withdraw permissions (location, Bluetooth, notifications) in Android settings;
- turn off personalised ads with the switch in the app (Settings → Privacy), and additionally reset or opt out of the advertising identifier in Android settings;
- contact the developer (see section 15 “Contact”) to request access, correction or erasure, or to complain. We respond within 30 days. Please note that, because the app has no accounts, we have no technical means to link an anonymous crash report to a specific person; in such cases we will help you delete on-device data and point you to the relevant provider;
- lodge a complaint with a supervisory authority in your country of residence (in the EEA/UK, your data protection authority; in Russia, Roskomnadzor).
Children
The app is intended for drivers and vehicle owners and is not directed at children under 16. We do not knowingly collect children’s data. If you believe a child has provided data to the developer, write to us at the address in section 15 “Contact” and it will be deleted.
Security
App data is stored in the app’s private directory, isolated from other apps by Android. The connection to the OBD-II adapter is local (Bluetooth); no internet connection is used to transfer vehicle data. Transmission to the third-party services listed in Appendix A is performed over secure channels by their SDKs. Short-link files are fetched over HTTPS only, and the app accepts a file only if its checksum matches the identifier in the link. The content of any file or link is checked before import exactly as what you type in the editors is, and nothing is written without your confirmation.
No technical measure guarantees absolute security. If a vulnerability affecting users is discovered, we will disclose it in the update notes and, where necessary, through the app store.
Safety notice
The app displays on-board diagnostic data and is not a measuring instrument or a certified diagnostic device. Do not interact with the app while driving. The developer is not liable for decisions made on the basis of the app’s readings.
Changes to this Policy
We may update this Policy when the app’s functionality or its set of third-party services changes. The current version is always available at the address shown on the app’s store listing and in the app’s Settings screen. For material changes (a new category of collected data, or a new recipient) we will say so in the update notes. The version date is stated at the top of this document; earlier versions are available on request.
Contact
For any privacy or data protection question:
If you write to us — at this address, at hello@denis55ka.app, or from the app (Settings → Write to the developer) — we receive your email address, the text of your message and anything you attach to it. A message started from the app opens in your own email client and already contains the app version, the store the installed build was made for, the device model and the Android version: this helps us answer to the point, and you can delete any of it before sending. The app itself sends nothing — the message leaves only when you send it. Correspondence is used solely to answer your request, is not shared with third parties, and is kept in the developer’s mailbox with their email provider.
Appendix A. Third-party services
The first table applies to every channel. The second applies only to an app installed from Google Play, the third only to one installed from RuStore. A component listed in none of them is absent: its SDK is shipped in no build, and the app does not reach it. The one exception is RuStore’s payments SDK, described below the tables.
| Service | Provider | Purpose | Data | Policy |
|---|---|---|---|---|
| AppMetrica | Yandex LLC | crash reporting and aggregated audience metrics, and at the same time the technical service of the ad SDK (section 5) | device model, OS and app version, stack trace, technical action trail, installation identifier, install store, the usage events listed in section 4; advertising identifier only while personalised ads are on (section 5) | yandex.com/legal/metrica_termsofuse |
| Yandex Mobile Ads | Yandex LLC | advertising | advertising identifier (only while personalised ads are on — section 5), device and network information, approximate location from IP, impression data, install-source data (only while personalised ads are on) | yandex.com/legal/confidential |
| Yandex Cloud (Object Storage, API Gateway, Serverless Containers) | Yandex.Cloud LLC | storing and serving the short-link files at dkonnect.denis55ka.app, and the server at api.dkonnect.denis55ka.app that publishes them (section 5). Not an SDK: the app reaches them over HTTPS only when you open or create a link | IP address and routine request headers; the content you share by link | yandex.ru/legal/cloud_termsofuse |
Additionally, in the Google Play build only. An app installed from Google Play sends its crash reports to a second recipient besides AppMetrica, contains Google Play’s billing library, and asks Google Play for its install source itself. The RuStore and direct-APK builds contain none of these components.
| Service | Provider | Purpose | Data | Policy |
|---|---|---|---|---|
| Firebase Crashlytics | Google LLC | crash reporting — a second recipient, in parallel with AppMetrica | device model, OS and app version, stack trace, crash time, technical action trail, the app’s installation identifier, plus Firebase’s own installation identifier and session data that the library generates itself. The advertising identifier is not collected under any position of the switch in section 5 | firebase.google.com/support/privacy |
| Google Play Billing Library | Google LLC | in-app purchases through Google Play (section 6). No paid features are offered yet, so no purchase can be started | while no purchase is made, none from the app. Once purchases appear: the purchase and its status, processed by Google Play; card details stay with Google Play | policies.google.com/privacy |
| Google Play Install Referrer Library | Google LLC | opening the short link whose page the app was installed from (section 5, “Installing from a link’s page”). One request, on the first launch | none from the app: the library receives from the Google Play app on the device the install source the store kept | policies.google.com/privacy |
Additionally, in the RuStore build only. The Google Play and direct-APK builds do not contain this component.
| Service | Provider | Purpose | Data | Policy |
|---|---|---|---|---|
| RuStore SDK Install Referrer | the rights holder of the RuStore service | opening the short link whose page the app was installed from (section 5, “Installing from a link’s page”). One request, on the first launch. Its functions that send events to VK Ads and its VKR analytics are neither enabled nor called | the SDK receives the install source from the RuStore app on the device. On a request the SDK itself sends service events about its own work to RuStore’s servers: the install source it received (the link’s identifier), the app’s package name and version, the SDK’s name and version, the time of the event and a random identifier that the SDK generates itself and keeps on the device | rustore.ru/help/legal/privacy-policy-users |
No paid features are offered yet. The Google Play build already contains Google Play’s billing library (the table above), but no purchase can be started in it. RuStore’s payments SDK is already shipped in every build too, but it is not configured and not used: no purchase can be started, and it sends no data. It will be added to the tables of this Appendix in the release that brings purchases to RuStore.
Firebase Analytics is shipped in no build. Earlier versions of the app used it alongside Crashlytics in the Google Play build; analytics in every channel is now AppMetrica’s, and what is left of Firebase is crash reporting plus the service libraries it brings with it (Firebase Installations, Firebase Sessions and the report delivery transport). Every build does contain Google libraries that supply the advertising identifier and the App Set ID to the SDKs above (play-services-ads-identifier, play-services-appset); these read identifiers on the device and are not themselves recipients of your data.
If a build with a different set of third-party services is released, this Appendix will be updated in the same release.