├── app
    ├── .gitignore
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   ├── values
    │   │   │   │   ├── strings.xml
    │   │   │   │   ├── colors.xml
    │   │   │   │   └── styles.xml
    │   │   │   ├── mipmap-hdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-mdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xxhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xxxhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-anydpi-v26
    │   │   │   │   ├── ic_launcher.xml
    │   │   │   │   └── ic_launcher_round.xml
    │   │   │   ├── layout
    │   │   │   │   └── activity_main.xml
    │   │   │   ├── drawable-v24
    │   │   │   │   └── ic_launcher_foreground.xml
    │   │   │   └── drawable
    │   │   │   │   └── ic_launcher_background.xml
    │   │   ├── java
    │   │   │   └── org
    │   │   │   │   └── altbeacon
    │   │   │   │       ├── beaconreference
    │   │   │   │           ├── BeaconRangingSmoother.kt
    │   │   │   │           ├── MainActivity.kt
    │   │   │   │           └── BeaconReferenceApplication.kt
    │   │   │   │       └── beacon
    │   │   │   │           └── permissions
    │   │   │   │               └── PermissionsActivity.kt
    │   │   └── AndroidManifest.xml
    │   ├── test
    │   │   └── java
    │   │   │   └── org
    │   │   │       └── altbeacon
    │   │   │           └── beaconreference
    │   │   │               └── ExampleUnitTest.kt
    │   └── androidTest
    │   │   └── java
    │   │       └── org
    │   │           └── altbeacon
    │   │               └── beaconreference
    │   │                   └── ExampleInstrumentedTest.kt
    ├── proguard-rules.pro
    └── build.gradle
├── .idea
    ├── .name
    ├── compiler.xml
    ├── kotlinc.xml
    ├── vcs.xml
    ├── deploymentTargetDropDown.xml
    ├── migrations.xml
    ├── misc.xml
    └── gradle.xml
├── android-beacon-library
├── settings.gradle
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── .gitignore
├── README.md
├── gradle.properties
├── gradlew.bat
├── gradlew
└── LICENSE


/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/.idea/.name:
--------------------------------------------------------------------------------
1 | BeaconReference


--------------------------------------------------------------------------------
/android-beacon-library:
--------------------------------------------------------------------------------
1 | ../android-beacon-library


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">BeaconReference</string>
3 | </resources>


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app'
2 | //include ':android-beacon-library:lib'
3 | rootProject.name = "BeaconReference"
4 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidgyoung/android-beacon-library-reference-kotlin/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/.idea/compiler.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="CompilerConfiguration">
4 |     <bytecodeTargetLevel target="17" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/kotlinc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="KotlinJpsPluginSettings">
4 |     <option name="version" value="1.8.0" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorPrimary">#6200EE</color>
4 |     <color name="colorPrimaryDark">#3700B3</color>
5 |     <color name="colorAccent">#03DAC5</color>
6 | </resources>


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="" vcs="Git" />
5 |     <mapping directory="$PROJECT_DIR$/android-beacon-library" vcs="Git" />
6 |   </component>
7 | </project>


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.iml
 2 | .gradle
 3 | /local.properties
 4 | /.idea/caches
 5 | /.idea/libraries
 6 | /.idea/modules.xml
 7 | /.idea/workspace.xml
 8 | /.idea/navEditor.xml
 9 | /.idea/assetWizardSettings.xml
10 | .DS_Store
11 | /build
12 | /captures
13 | .externalNativeBuild
14 | .cxx
15 | 


--------------------------------------------------------------------------------
/.idea/deploymentTargetDropDown.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="deploymentTargetDropDown">
 4 |     <value>
 5 |       <entry key="app">
 6 |         <State />
 7 |       </entry>
 8 |     </value>
 9 |   </component>
10 | </project>


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Sun Aug 01 15:02:41 EDT 2021
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
7 | 


--------------------------------------------------------------------------------
/.idea/migrations.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="ProjectMigrations">
 4 |     <option name="MigrateToGradleLocalJavaHome">
 5 |       <set>
 6 |         <option value="$PROJECT_DIR$" />
 7 |       </set>
 8 |     </option>
 9 |   </component>
10 | </project>


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background" />
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground" />
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background" />
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground" />
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Overview
 2 | 
 3 | This is a Kotlin reference app for the AndroidBeaconLibrary
 4 | 
 5 | ## Project Setup
 6 | 
 7 | 1. Install [Android Studio](https://developer.android.com/sdk/installing/studio.html) Android Studio Hedgehog | 2023.1.1+
 8 | 2. Open this project
 9 | 
10 | See the [Java refernce app here.](https://github.com/davidgyoung/android-beacon-library-reference-java)
11 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 |     <!-- Base application theme. -->
 3 |     <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
 4 |         <!-- Customize your theme here. -->
 5 |         <item name="colorPrimary">@color/colorPrimary</item>
 6 |         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
 7 |         <item name="colorAccent">@color/colorAccent</item>
 8 |     </style>
 9 | 
10 | </resources>


--------------------------------------------------------------------------------
/app/src/test/java/org/altbeacon/beaconreference/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
 1 | package org.altbeacon.beaconreference
 2 | 
 3 | import org.junit.Test
 4 | 
 5 | import org.junit.Assert.*
 6 | 
 7 | /**
 8 |  * Example local unit test, which will execute on the development machine (host).
 9 |  *
10 |  * See [testing documentation](http://d.android.com/tools/testing).
11 |  */
12 | class ExampleUnitTest {
13 |     @Test
14 |     fun addition_isCorrect() {
15 |         assertEquals(4, 2 + 2)
16 |     }
17 | }


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="ExternalStorageConfigurationManager" enabled="true" />
 4 |   <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
 5 |     <output url="file://$PROJECT_DIR$/build/classes" />
 6 |   </component>
 7 |   <component name="ProjectType">
 8 |     <option name="id" value="Android" />
 9 |   </component>
10 | </project>


--------------------------------------------------------------------------------
/.idea/gradle.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="GradleSettings">
 4 |     <option name="linkedExternalProjectsSettings">
 5 |       <GradleProjectSettings>
 6 |         <option name="externalProjectPath" value="$PROJECT_DIR$" />
 7 |         <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
 8 |         <option name="modules">
 9 |           <set>
10 |             <option value="$PROJECT_DIR$" />
11 |             <option value="$PROJECT_DIR$/app" />
12 |           </set>
13 |         </option>
14 |         <option name="resolveExternalAnnotations" value="false" />
15 |       </GradleProjectSettings>
16 |     </option>
17 |   </component>
18 | </project>


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/app/src/androidTest/java/org/altbeacon/beaconreference/ExampleInstrumentedTest.kt:
--------------------------------------------------------------------------------
 1 | package org.altbeacon.beaconreference
 2 | 
 3 | import androidx.test.platform.app.InstrumentationRegistry
 4 | import androidx.test.ext.junit.runners.AndroidJUnit4
 5 | 
 6 | import org.junit.Test
 7 | import org.junit.runner.RunWith
 8 | 
 9 | import org.junit.Assert.*
10 | 
11 | /**
12 |  * Instrumented test, which will execute on an Android device.
13 |  *
14 |  * See [testing documentation](http://d.android.com/tools/testing).
15 |  */
16 | @RunWith(AndroidJUnit4::class)
17 | class ExampleInstrumentedTest {
18 |     @Test
19 |     fun useAppContext() {
20 |         // Context of the app under test.
21 |         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
22 |         assertEquals("org.altbeacon.beaconreference", appContext.packageName)
23 |     }
24 | }


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | # IDE (e.g. Android Studio) users:
 3 | # Gradle settings configured through the IDE *will override*
 4 | # any settings specified in this file.
 5 | # For more details on how to configure your build environment visit
 6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 7 | # Specifies the JVM arguments used for the daemon process.
 8 | # The setting is particularly useful for tweaking memory settings.
 9 | org.gradle.jvmargs=-Xmx2048m
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. More details, visit
12 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app"s APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Automatically convert third-party libraries to use AndroidX
19 | android.enableJetifier=true
20 | # Kotlin code style for this project: "official" or "obsolete":
21 | kotlin.code.style=official
22 | android.defaults.buildfeatures.buildconfig=true
23 | android.nonTransitiveRClass=false
24 | android.nonFinalResIds=false


--------------------------------------------------------------------------------
/app/src/main/java/org/altbeacon/beaconreference/BeaconRangingSmoother.kt:
--------------------------------------------------------------------------------
 1 | package org.altbeacon.beaconreference
 2 | 
 3 | import org.altbeacon.beacon.Beacon
 4 | import java.util.ArrayList
 5 | 
 6 | /*
 7 |  * This class is used to smooth out the beacon ranging data to prevent periodic dropouts.  By
 8 |  * default, it will retain beacons in the list if detected in the past 10 secconds, but you can
 9 |  * adjust this with the smoothingWindowMillis property.
10 |  *
11 |  * To use this class, simply add it to your project and call a line like below wherever you get
12 |  * an update of ranged beacons (in an observer or in didRangeBeacons):
13 |  *
14 |  *  val visibleBeacons = BeaconRangingSmoother.shared.add(beacons).visibleBeacons
15 |  */
16 | class BeaconRangingSmoother {
17 |     private var beacons: ArrayList<Beacon> = ArrayList<Beacon>()
18 |     var smoothingWindowMillis: Long = 10000
19 |     var visibleBeacons: List<Beacon> = ArrayList<Beacon>()
20 |         get() {
21 |             var visible = ArrayList<Beacon>()
22 |             for (beacon in beacons) {
23 |                 if (System.currentTimeMillis() - beacon.lastCycleDetectionTimestamp < smoothingWindowMillis) {
24 |                     visible.add(beacon)
25 |                 }
26 |             }
27 |             return visible
28 |         }
29 |     fun add(detectedBeacons: Collection<Beacon>): BeaconRangingSmoother {
30 |         for (beacon in detectedBeacons) {
31 |             beacon.lastCycleDetectionTimestamp = System.currentTimeMillis()
32 |             beacons.add(beacon)
33 |         }
34 |         return this
35 |     }
36 |     companion object {
37 |         val TAG = "BeaconRangingSmoother"
38 |         val shared = BeaconRangingSmoother()
39 |     }
40 | }


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 3 |     <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
 4 |     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
 5 |     <uses-permission android:name="android.permission.INTERNET"/>
 6 |     <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
 7 |     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 8 |     <uses-permission android:name="android.permission.BLUETOOTH_SCAN"/>
 9 |     <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE"/>
10 |     <!-- Below is only needed if you want to read the device name or establish a bluetooth connection
11 |     -->
12 |     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
13 | 
14 |     <application
15 |         android:name="BeaconReferenceApplication"
16 |         android:allowBackup="true"
17 |         android:icon="@mipmap/ic_launcher"
18 |         android:label="@string/app_name"
19 |         android:roundIcon="@mipmap/ic_launcher_round"
20 |         android:supportsRtl="true"
21 |         android:theme="@style/AppTheme">
22 |         <activity android:name=".MainActivity" android:exported="true">
23 |             <intent-filter>
24 |                 <action android:name="android.intent.action.MAIN" />
25 |                 <category android:name="android.intent.category.LAUNCHER" />
26 |             </intent-filter>
27 |         </activity>
28 |         <activity android:name="org.altbeacon.beacon.permissions.BeaconScanPermissionsActivity"
29 |             android:exported="false"/>
30 |     </application>
31 | 
32 | </manifest>


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:app="http://schemas.android.com/apk/res-auto"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent"
 7 |     android:orientation="vertical"
 8 |     tools:context=".MainActivity">
 9 | 
10 |     <TextView
11 |         android:id="@+id/beaconCount"
12 |         android:text="0 visible beacons:"
13 |         android:textAlignment="center"
14 |         android:layout_width="match_parent"
15 |         android:layout_height="20dp"/>
16 |     <ListView
17 |         android:id="@+id/beaconList"
18 |         android:layout_width="match_parent"
19 |         android:layout_height="0dp"
20 |         android:layout_weight="1">
21 |     </ListView>
22 |     <LinearLayout
23 |         android:layout_width="match_parent"
24 |         android:layout_height="wrap_content"
25 |         android:orientation="horizontal"
26 |         android:layout_weight="0">
27 |         <Button
28 |             android:id="@+id/rangingButton"
29 |             android:onClick="rangingButtonTapped"
30 |             android:text="Disable Ranging"
31 |             android:layout_width="0dp"
32 |             android:layout_height="50dp"
33 |             android:layout_weight="1">
34 |         </Button>
35 |         <Button
36 |             android:id="@+id/monitoringButton"
37 |             android:text="Disable Monitoring"
38 |             android:onClick="monitoringButtonTapped"
39 |             android:layout_width="0dp"
40 |             android:layout_height="50dp"
41 |             android:layout_weight="1">
42 |         </Button>
43 |     </LinearLayout>
44 | 
45 | </LinearLayout>


--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
 1 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     xmlns:aapt="http://schemas.android.com/aapt"
 3 |     android:width="108dp"
 4 |     android:height="108dp"
 5 |     android:viewportWidth="108"
 6 |     android:viewportHeight="108">
 7 |     <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
 8 |         <aapt:attr name="android:fillColor">
 9 |             <gradient
10 |                 android:endX="85.84757"
11 |                 android:endY="92.4963"
12 |                 android:startX="42.9492"
13 |                 android:startY="49.59793"
14 |                 android:type="linear">
15 |                 <item
16 |                     android:color="#44000000"
17 |                     android:offset="0.0" />
18 |                 <item
19 |                     android:color="#00000000"
20 |                     android:offset="1.0" />
21 |             </gradient>
22 |         </aapt:attr>
23 |     </path>
24 |     <path
25 |         android:fillColor="#FFFFFF"
26 |         android:fillType="nonZero"
27 |         android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
28 |         android:strokeWidth="1"
29 |         android:strokeColor="#00000000" />
30 | </vector>


--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
 1 | apply plugin: 'com.android.application'
 2 | apply plugin: 'kotlin-android'
 3 | 
 4 | android {
 5 |     compileSdkVersion 34
 6 |     buildToolsVersion "34.0.0"
 7 | 
 8 |     defaultConfig {
 9 |         applicationId "org.altbeacon.beaconreference"
10 |         minSdkVersion 26
11 |         targetSdkVersion 34
12 |         versionCode 1
13 |         versionName "1.0"
14 | 
15 |         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
16 |     }
17 | 
18 |     buildTypes {
19 |         release {
20 |             minifyEnabled false
21 |             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
22 |         }
23 |     }
24 |     buildFeatures {
25 |         viewBinding true
26 |     }
27 |     compileOptions {
28 |         sourceCompatibility JavaVersion.VERSION_17
29 |         targetCompatibility JavaVersion.VERSION_17
30 |     }
31 |     kotlinOptions {
32 |         jvmTarget = '17'
33 |     }
34 |     namespace 'org.altbeacon.beaconreference'
35 | }
36 | 
37 | dependencies {
38 |     implementation fileTree(dir: "libs", include: ["*.jar"])
39 |     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
40 |     implementation 'androidx.core:core-ktx:1.3.1'
41 |     implementation 'androidx.appcompat:appcompat:1.3.1'
42 |     implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
43 |     implementation('com.davidgyoungtech:beacon-parsers:1.0') {
44 |         exclude group: 'org.altbeacon'
45 |     }
46 |     implementation 'org.altbeacon:android-beacon-library:2+'
47 |     //implementation project(':android-beacon-library:lib')
48 | 
49 |     //coroutines
50 |     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2'
51 |     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2"
52 |     //coroutine scopes
53 |     implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0"
54 |     testImplementation 'junit:junit:4.12'
55 |     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
56 |     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
57 | }
58 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @if "%DEBUG%" == "" @echo off
 2 | @rem ##########################################################################
 3 | @rem
 4 | @rem  Gradle startup script for Windows
 5 | @rem
 6 | @rem ##########################################################################
 7 | 
 8 | @rem Set local scope for the variables with windows NT shell
 9 | if "%OS%"=="Windows_NT" setlocal
10 | 
11 | set DIRNAME=%~dp0
12 | if "%DIRNAME%" == "" set DIRNAME=.
13 | set APP_BASE_NAME=%~n0
14 | set APP_HOME=%DIRNAME%
15 | 
16 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
17 | set DEFAULT_JVM_OPTS=
18 | 
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 | 
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 | 
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 | 
32 | goto fail
33 | 
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 | 
38 | if exist "%JAVA_EXE%" goto init
39 | 
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 | 
46 | goto fail
47 | 
48 | :init
49 | @rem Get command-line arguments, handling Windows variants
50 | 
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | 
53 | :win9xME_args
54 | @rem Slurp the command line arguments.
55 | set CMD_LINE_ARGS=
56 | set _SKIP=2
57 | 
58 | :win9xME_args_slurp
59 | if "x%~1" == "x" goto execute
60 | 
61 | set CMD_LINE_ARGS=%*
62 | 
63 | :execute
64 | @rem Setup the command line
65 | 
66 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
67 | 
68 | @rem Execute Gradle
69 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
70 | 
71 | :end
72 | @rem End local scope for the variables with windows NT shell
73 | if "%ERRORLEVEL%"=="0" goto mainEnd
74 | 
75 | :fail
76 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
77 | rem the _cmd.exe /c_ return code!
78 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
79 | exit /b 1
80 | 
81 | :mainEnd
82 | if "%OS%"=="Windows_NT" endlocal
83 | 
84 | :omega
85 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | ##############################################################################
  4 | ##
  5 | ##  Gradle start up script for UN*X
  6 | ##
  7 | ##############################################################################
  8 | 
  9 | # Attempt to set APP_HOME
 10 | # Resolve links: $0 may be a link
 11 | PRG="$0"
 12 | # Need this for relative symlinks.
 13 | while [ -h "$PRG" ] ; do
 14 |     ls=`ls -ld "$PRG"`
 15 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 16 |     if expr "$link" : '/.*' > /dev/null; then
 17 |         PRG="$link"
 18 |     else
 19 |         PRG=`dirname "$PRG"`"/$link"
 20 |     fi
 21 | done
 22 | SAVED="`pwd`"
 23 | cd "`dirname \"$PRG\"`/" >/dev/null
 24 | APP_HOME="`pwd -P`"
 25 | cd "$SAVED" >/dev/null
 26 | 
 27 | APP_NAME="Gradle"
 28 | APP_BASE_NAME=`basename "$0"`
 29 | 
 30 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 31 | DEFAULT_JVM_OPTS=""
 32 | 
 33 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 34 | MAX_FD="maximum"
 35 | 
 36 | warn () {
 37 |     echo "$*"
 38 | }
 39 | 
 40 | die () {
 41 |     echo
 42 |     echo "$*"
 43 |     echo
 44 |     exit 1
 45 | }
 46 | 
 47 | # OS specific support (must be 'true' or 'false').
 48 | cygwin=false
 49 | msys=false
 50 | darwin=false
 51 | nonstop=false
 52 | case "`uname`" in
 53 |   CYGWIN* )
 54 |     cygwin=true
 55 |     ;;
 56 |   Darwin* )
 57 |     darwin=true
 58 |     ;;
 59 |   MINGW* )
 60 |     msys=true
 61 |     ;;
 62 |   NONSTOP* )
 63 |     nonstop=true
 64 |     ;;
 65 | esac
 66 | 
 67 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 68 | 
 69 | # Determine the Java command to use to start the JVM.
 70 | if [ -n "$JAVA_HOME" ] ; then
 71 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 72 |         # IBM's JDK on AIX uses strange locations for the executables
 73 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 74 |     else
 75 |         JAVACMD="$JAVA_HOME/bin/java"
 76 |     fi
 77 |     if [ ! -x "$JAVACMD" ] ; then
 78 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 79 | 
 80 | Please set the JAVA_HOME variable in your environment to match the
 81 | location of your Java installation."
 82 |     fi
 83 | else
 84 |     JAVACMD="java"
 85 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 86 | 
 87 | Please set the JAVA_HOME variable in your environment to match the
 88 | location of your Java installation."
 89 | fi
 90 | 
 91 | # Increase the maximum file descriptors if we can.
 92 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
 93 |     MAX_FD_LIMIT=`ulimit -H -n`
 94 |     if [ $? -eq 0 ] ; then
 95 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
 96 |             MAX_FD="$MAX_FD_LIMIT"
 97 |         fi
 98 |         ulimit -n $MAX_FD
 99 |         if [ $? -ne 0 ] ; then
100 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
101 |         fi
102 |     else
103 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
104 |     fi
105 | fi
106 | 
107 | # For Darwin, add options to specify how the application appears in the dock
108 | if $darwin; then
109 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
110 | fi
111 | 
112 | # For Cygwin, switch paths to Windows format before running java
113 | if $cygwin ; then
114 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
115 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
116 |     JAVACMD=`cygpath --unix "$JAVACMD"`
117 | 
118 |     # We build the pattern for arguments to be converted via cygpath
119 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 |     SEP=""
121 |     for dir in $ROOTDIRSRAW ; do
122 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
123 |         SEP="|"
124 |     done
125 |     OURCYGPATTERN="(^($ROOTDIRS))"
126 |     # Add a user-defined pattern to the cygpath arguments
127 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 |     fi
130 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 |     i=0
132 |     for arg in "$@" ; do
133 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
135 | 
136 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
137 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 |         else
139 |             eval `echo args$i`="\"$arg\""
140 |         fi
141 |         i=$((i+1))
142 |     done
143 |     case $i in
144 |         (0) set -- ;;
145 |         (1) set -- "$args0" ;;
146 |         (2) set -- "$args0" "$args1" ;;
147 |         (3) set -- "$args0" "$args1" "$args2" ;;
148 |         (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 |         (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 |         (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 |         (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 |         (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 |         (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 |     esac
155 | fi
156 | 
157 | # Escape application args
158 | save () {
159 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
160 |     echo " "
161 | }
162 | APP_ARGS=$(save "$@")
163 | 
164 | # Collect all arguments for the java command, following the shell quoting and substitution rules
165 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
166 | 
167 | # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
168 | if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
169 |   cd "$(dirname "$0")"
170 | fi
171 | 
172 | exec "$JAVACMD" "$@"
173 | 


--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_launcher_background.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
  3 |     android:width="108dp"
  4 |     android:height="108dp"
  5 |     android:viewportWidth="108"
  6 |     android:viewportHeight="108">
  7 |     <path
  8 |         android:fillColor="#3DDC84"
  9 |         android:pathData="M0,0h108v108h-108z" />
 10 |     <path
 11 |         android:fillColor="#00000000"
 12 |         android:pathData="M9,0L9,108"
 13 |         android:strokeWidth="0.8"
 14 |         android:strokeColor="#33FFFFFF" />
 15 |     <path
 16 |         android:fillColor="#00000000"
 17 |         android:pathData="M19,0L19,108"
 18 |         android:strokeWidth="0.8"
 19 |         android:strokeColor="#33FFFFFF" />
 20 |     <path
 21 |         android:fillColor="#00000000"
 22 |         android:pathData="M29,0L29,108"
 23 |         android:strokeWidth="0.8"
 24 |         android:strokeColor="#33FFFFFF" />
 25 |     <path
 26 |         android:fillColor="#00000000"
 27 |         android:pathData="M39,0L39,108"
 28 |         android:strokeWidth="0.8"
 29 |         android:strokeColor="#33FFFFFF" />
 30 |     <path
 31 |         android:fillColor="#00000000"
 32 |         android:pathData="M49,0L49,108"
 33 |         android:strokeWidth="0.8"
 34 |         android:strokeColor="#33FFFFFF" />
 35 |     <path
 36 |         android:fillColor="#00000000"
 37 |         android:pathData="M59,0L59,108"
 38 |         android:strokeWidth="0.8"
 39 |         android:strokeColor="#33FFFFFF" />
 40 |     <path
 41 |         android:fillColor="#00000000"
 42 |         android:pathData="M69,0L69,108"
 43 |         android:strokeWidth="0.8"
 44 |         android:strokeColor="#33FFFFFF" />
 45 |     <path
 46 |         android:fillColor="#00000000"
 47 |         android:pathData="M79,0L79,108"
 48 |         android:strokeWidth="0.8"
 49 |         android:strokeColor="#33FFFFFF" />
 50 |     <path
 51 |         android:fillColor="#00000000"
 52 |         android:pathData="M89,0L89,108"
 53 |         android:strokeWidth="0.8"
 54 |         android:strokeColor="#33FFFFFF" />
 55 |     <path
 56 |         android:fillColor="#00000000"
 57 |         android:pathData="M99,0L99,108"
 58 |         android:strokeWidth="0.8"
 59 |         android:strokeColor="#33FFFFFF" />
 60 |     <path
 61 |         android:fillColor="#00000000"
 62 |         android:pathData="M0,9L108,9"
 63 |         android:strokeWidth="0.8"
 64 |         android:strokeColor="#33FFFFFF" />
 65 |     <path
 66 |         android:fillColor="#00000000"
 67 |         android:pathData="M0,19L108,19"
 68 |         android:strokeWidth="0.8"
 69 |         android:strokeColor="#33FFFFFF" />
 70 |     <path
 71 |         android:fillColor="#00000000"
 72 |         android:pathData="M0,29L108,29"
 73 |         android:strokeWidth="0.8"
 74 |         android:strokeColor="#33FFFFFF" />
 75 |     <path
 76 |         android:fillColor="#00000000"
 77 |         android:pathData="M0,39L108,39"
 78 |         android:strokeWidth="0.8"
 79 |         android:strokeColor="#33FFFFFF" />
 80 |     <path
 81 |         android:fillColor="#00000000"
 82 |         android:pathData="M0,49L108,49"
 83 |         android:strokeWidth="0.8"
 84 |         android:strokeColor="#33FFFFFF" />
 85 |     <path
 86 |         android:fillColor="#00000000"
 87 |         android:pathData="M0,59L108,59"
 88 |         android:strokeWidth="0.8"
 89 |         android:strokeColor="#33FFFFFF" />
 90 |     <path
 91 |         android:fillColor="#00000000"
 92 |         android:pathData="M0,69L108,69"
 93 |         android:strokeWidth="0.8"
 94 |         android:strokeColor="#33FFFFFF" />
 95 |     <path
 96 |         android:fillColor="#00000000"
 97 |         android:pathData="M0,79L108,79"
 98 |         android:strokeWidth="0.8"
 99 |         android:strokeColor="#33FFFFFF" />
100 |     <path
101 |         android:fillColor="#00000000"
102 |         android:pathData="M0,89L108,89"
103 |         android:strokeWidth="0.8"
104 |         android:strokeColor="#33FFFFFF" />
105 |     <path
106 |         android:fillColor="#00000000"
107 |         android:pathData="M0,99L108,99"
108 |         android:strokeWidth="0.8"
109 |         android:strokeColor="#33FFFFFF" />
110 |     <path
111 |         android:fillColor="#00000000"
112 |         android:pathData="M19,29L89,29"
113 |         android:strokeWidth="0.8"
114 |         android:strokeColor="#33FFFFFF" />
115 |     <path
116 |         android:fillColor="#00000000"
117 |         android:pathData="M19,39L89,39"
118 |         android:strokeWidth="0.8"
119 |         android:strokeColor="#33FFFFFF" />
120 |     <path
121 |         android:fillColor="#00000000"
122 |         android:pathData="M19,49L89,49"
123 |         android:strokeWidth="0.8"
124 |         android:strokeColor="#33FFFFFF" />
125 |     <path
126 |         android:fillColor="#00000000"
127 |         android:pathData="M19,59L89,59"
128 |         android:strokeWidth="0.8"
129 |         android:strokeColor="#33FFFFFF" />
130 |     <path
131 |         android:fillColor="#00000000"
132 |         android:pathData="M19,69L89,69"
133 |         android:strokeWidth="0.8"
134 |         android:strokeColor="#33FFFFFF" />
135 |     <path
136 |         android:fillColor="#00000000"
137 |         android:pathData="M19,79L89,79"
138 |         android:strokeWidth="0.8"
139 |         android:strokeColor="#33FFFFFF" />
140 |     <path
141 |         android:fillColor="#00000000"
142 |         android:pathData="M29,19L29,89"
143 |         android:strokeWidth="0.8"
144 |         android:strokeColor="#33FFFFFF" />
145 |     <path
146 |         android:fillColor="#00000000"
147 |         android:pathData="M39,19L39,89"
148 |         android:strokeWidth="0.8"
149 |         android:strokeColor="#33FFFFFF" />
150 |     <path
151 |         android:fillColor="#00000000"
152 |         android:pathData="M49,19L49,89"
153 |         android:strokeWidth="0.8"
154 |         android:strokeColor="#33FFFFFF" />
155 |     <path
156 |         android:fillColor="#00000000"
157 |         android:pathData="M59,19L59,89"
158 |         android:strokeWidth="0.8"
159 |         android:strokeColor="#33FFFFFF" />
160 |     <path
161 |         android:fillColor="#00000000"
162 |         android:pathData="M69,19L69,89"
163 |         android:strokeWidth="0.8"
164 |         android:strokeColor="#33FFFFFF" />
165 |     <path
166 |         android:fillColor="#00000000"
167 |         android:pathData="M79,19L79,89"
168 |         android:strokeWidth="0.8"
169 |         android:strokeColor="#33FFFFFF" />
170 | </vector>
171 | 


--------------------------------------------------------------------------------
/app/src/main/java/org/altbeacon/beaconreference/MainActivity.kt:
--------------------------------------------------------------------------------
  1 | package org.altbeacon.beaconreference
  2 | 
  3 | import android.app.AlertDialog
  4 | import android.os.Bundle
  5 | import android.util.Log
  6 | import android.view.View
  7 | import android.widget.ArrayAdapter
  8 | import android.widget.Button
  9 | import android.widget.ListView
 10 | import android.widget.TextView
 11 | import androidx.appcompat.app.AppCompatActivity
 12 | import androidx.lifecycle.Observer
 13 | import org.altbeacon.beacon.Beacon
 14 | import org.altbeacon.beacon.BeaconManager
 15 | import org.altbeacon.beacon.MonitorNotifier
 16 | import android.content.Intent
 17 | import android.os.Handler
 18 | import android.os.Looper
 19 | import org.altbeacon.beacon.permissions.BeaconScanPermissionsActivity
 20 | 
 21 | class MainActivity : AppCompatActivity() {
 22 |     private lateinit var beaconListView: ListView
 23 |     private lateinit var beaconCountTextView: TextView
 24 |     private lateinit var monitoringButton: Button
 25 |     private lateinit var rangingButton: Button
 26 |     private lateinit var beaconReferenceApplication: BeaconReferenceApplication
 27 |     private var alertDialog: AlertDialog? = null
 28 | 
 29 |     override fun onCreate(savedInstanceState: Bundle?) {
 30 |         super.onCreate(savedInstanceState)
 31 |         setContentView(R.layout.activity_main)
 32 |         beaconReferenceApplication = application as BeaconReferenceApplication
 33 | 
 34 |         // Set up a Live Data observer for beacon data
 35 |         val regionViewModel = BeaconManager.getInstanceForApplication(this).getRegionViewModel(beaconReferenceApplication.wildcardIBeaconRegion)
 36 |         // observer will be called each time the monitored regionState changes (inside vs. outside region)
 37 |         regionViewModel.regionState.observe(this, monitoringObserver)
 38 |         // observer will be called each time a new list of beacons is ranged (typically ~1 second in the foreground)
 39 |         regionViewModel.rangedBeacons.observe(this, rangingObserver)
 40 |         rangingButton = findViewById<Button>(R.id.rangingButton)
 41 |         monitoringButton = findViewById<Button>(R.id.monitoringButton)
 42 |         beaconListView = findViewById<ListView>(R.id.beaconList)
 43 |         beaconCountTextView = findViewById<TextView>(R.id.beaconCount)
 44 |         beaconCountTextView.text = "No beacons detected"
 45 |         beaconListView.adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, arrayOf("--"))
 46 |     }
 47 | 
 48 |     override fun onPause() {
 49 |         Log.d(TAG, "onPause")
 50 |         super.onPause()
 51 |     }
 52 |     override fun onResume() {
 53 |         Log.d(TAG, "onResume")
 54 |         super.onResume()
 55 |         // You MUST make sure the following dynamic permissions are granted by the user to detect beacons
 56 |         //
 57 |         //    Manifest.permission.BLUETOOTH_SCAN
 58 |         //    Manifest.permission.BLUETOOTH_CONNECT
 59 |         //    Manifest.permission.ACCESS_FINE_LOCATION
 60 |         //    Manifest.permission.ACCESS_BACKGROUND_LOCATION // only needed to detect in background
 61 |         //
 62 |         // The code needed to get these permissions has become increasingly complex, so it is in
 63 |         // its own file so as not to clutter this file focussed on how to use the library.
 64 | 
 65 |         if (!BeaconScanPermissionsActivity.allPermissionsGranted(this,
 66 |                 true)) {
 67 |             val intent = Intent(this, BeaconScanPermissionsActivity::class.java)
 68 |             intent.putExtra("backgroundAccessRequested", true)
 69 |             startActivity(intent)
 70 |         }
 71 |         else {
 72 |             // All permissions are granted now.  In the case where we are configured
 73 |             // to use a foreground service, we will not have been able to start scanning until
 74 |             // after permissions are granted.  So we will do so here.
 75 |             if (BeaconManager.getInstanceForApplication(this).monitoredRegions.size == 0) {
 76 |                 (application as BeaconReferenceApplication).setupBeaconScanning()
 77 |             }
 78 |         }
 79 |     }
 80 | 
 81 |     val monitoringObserver = Observer<Int> { state ->
 82 |         var dialogTitle = "Beacons detected"
 83 |         var dialogMessage = "didEnterRegionEvent has fired"
 84 |         var stateString = "inside"
 85 |         if (state == MonitorNotifier.OUTSIDE) {
 86 |             dialogTitle = "No beacons detected"
 87 |             dialogMessage = "didExitRegionEvent has fired"
 88 |             stateString == "outside"
 89 |             beaconCountTextView.text = "Outside of the beacon region -- no beacons detected"
 90 |             beaconListView.adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, arrayOf("--"))
 91 |         }
 92 |         else {
 93 |             beaconCountTextView.text = "Inside the beacon region."
 94 |         }
 95 |         Log.d(TAG, "monitoring state changed to : $stateString")
 96 |         val builder =
 97 |             AlertDialog.Builder(this)
 98 |         builder.setTitle(dialogTitle)
 99 |         builder.setMessage(dialogMessage)
100 |         builder.setPositiveButton(android.R.string.ok, null)
101 |         alertDialog?.dismiss()
102 |         alertDialog = builder.create()
103 |         alertDialog?.show()
104 |     }
105 | 
106 |     val rangingObserver = Observer<Collection<Beacon>> { beacons ->
107 |         Log.d(TAG, "Ranged: ${beacons.count()} beacons")
108 |         if (BeaconManager.getInstanceForApplication(this).rangedRegions.size > 0) {
109 |             beaconCountTextView.text = "Ranging enabled: ${beacons.count()} beacon(s) detected"
110 |             beaconListView.adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1,
111 |                 beacons
112 |                     .sortedBy { it.distance }
113 |                     .map { "${it.id1}\nid2: ${it.id2} id3:  rssi: ${it.rssi}\nest. distance: ${it.distance} m" }.toTypedArray())
114 |         }
115 |     }
116 | 
117 |     fun rangingButtonTapped(view: View) {
118 |         val beaconManager = BeaconManager.getInstanceForApplication(this)
119 |         if (beaconManager.rangedRegions.isEmpty()) {
120 |             beaconManager.startRangingBeacons(beaconReferenceApplication.wildcardIBeaconRegion)
121 |             rangingButton.text = "Stop Ranging"
122 |             beaconCountTextView.text = "Ranging enabled -- awaiting first callback"
123 |         }
124 |         else {
125 |             beaconManager.stopRangingBeacons(beaconReferenceApplication.wildcardIBeaconRegion)
126 |             rangingButton.text = "Start Ranging"
127 |             beaconCountTextView.text = "Ranging disabled -- no beacons detected"
128 |             beaconListView.adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, arrayOf("--"))
129 |         }
130 |     }
131 | 
132 |     fun monitoringButtonTapped(view: View) {
133 |         var dialogTitle = ""
134 |         var dialogMessage = ""
135 |         val beaconManager = BeaconManager.getInstanceForApplication(this)
136 |         if (beaconManager.monitoredRegions.isEmpty()) {
137 |             beaconManager.startMonitoring(beaconReferenceApplication.wildcardIBeaconRegion)
138 |             dialogTitle = "Beacon monitoring started."
139 |             dialogMessage = "You will see a dialog if a beacon is detected, and another if beacons then stop being detected."
140 |             monitoringButton.text = "Stop Monitoring"
141 | 
142 |         }
143 |         else {
144 |             beaconManager.stopMonitoring(beaconReferenceApplication.wildcardIBeaconRegion)
145 |             dialogTitle = "Beacon monitoring stopped."
146 |             dialogMessage = "You will no longer see dialogs when beacons start/stop being detected."
147 |             monitoringButton.text = "Start Monitoring"
148 |         }
149 |         val builder =
150 |             AlertDialog.Builder(this)
151 |         builder.setTitle(dialogTitle)
152 |         builder.setMessage(dialogMessage)
153 |         builder.setPositiveButton(android.R.string.ok, null)
154 |         alertDialog?.dismiss()
155 |         alertDialog = builder.create()
156 |         alertDialog?.show()
157 | 
158 |     }
159 | 
160 |     companion object {
161 |         val TAG = "MainActivity"
162 |     }
163 | 
164 | }
165 | 


--------------------------------------------------------------------------------
/app/src/main/java/org/altbeacon/beaconreference/BeaconReferenceApplication.kt:
--------------------------------------------------------------------------------
  1 | package org.altbeacon.beaconreference
  2 | 
  3 | import android.app.*
  4 | import android.content.Context
  5 | import android.content.Intent
  6 | import android.util.Log
  7 | import androidx.core.app.NotificationCompat
  8 | import androidx.lifecycle.Observer
  9 | import com.davidgyoungtech.beaconparsers.IBeaconParser
 10 | import org.altbeacon.beacon.*
 11 | 
 12 | class BeaconReferenceApplication: Application() {
 13 |     // the region definition is a wildcard that matches all beacons regardless of identifiers.
 14 |     // if you only want to detect beacons with a specific UUID, change the id1 paremeter to
 15 |     // a UUID like Identifier.parse("2F234454-CF6D-4A0F-ADF2-F4911BA9FFA6")
 16 |     // Each BeaconRegion must specify a beacon parser, which defines what format of Bluetooth beacon
 17 |     // to match, e.g. (iBeacon, AltBeacon, Eddystone UID, etc.)
 18 |     // The first parameter uniqueId is a string key that is used to identify this region in the
 19 |     // library.  This string key must be unique for each region you define, and the same uniqueID
 20 |     // must be used to tell the library to start and stop beacon ranging and monitoring.
 21 |     val wildcardIBeaconRegion = BeaconRegion("everyIBeaconRegion", IBeaconParser() /* from com.davidgyoungtech:beacon-parsers:1.0 */, null, null, null)
 22 |     // Below are examples of other region definitions for other beacon formats
 23 |     //val wildcardAltBeaconRegion = BeaconRegion("everyAltBeaconRegion", AltBeaconParser(), null, null, null)
 24 |     //val everyEddystoneUidBeaconRegion = BeaconRegion("everyEddystoneUidBeaconRegion", EddystoneUidBeaconParser(), null, null, null)
 25 |     //val everyEddystoneUrlBeaconRegion = BeaconRegion("everyEddystoneUrlBeaconRegion", EddystoneUrlBeaconParser(), null, null, null)
 26 | 
 27 |     override fun onCreate() {
 28 |         super.onCreate()
 29 |         setupBeaconScanning()
 30 |     }
 31 | 
 32 |     fun setupBeaconScanning() {
 33 |         val beaconManager = BeaconManager.getInstanceForApplication(this)
 34 | 
 35 |         // The intent scan strategy configured below will set up Blutooth scanning to find beacons
 36 |         // that are delivered by Android Intent.  This works well for background detections.
 37 |         // If you don't need background detections, then you don't need to set any settings, and
 38 |         // can accept the default with is to use a service to do the scanning.  This works well for
 39 |         // beacon detections when the app is in the foreground.
 40 |         //val settings = Settings(scanStrategy = Settings.IntentScanStrategy(), longScanForcingEnabled = true)
 41 |         // You can also use the library's built-in "foreground service" to scan for beacons while
 42 |         // the app is in the background using the code below.  This shows a notification to
 43 |         // the user that your app is running , and will require the ACCESS_BACKGROUND_LOCATION
 44 |         // permission to be granted by the user in advance.
 45 |         //val settings = getSettingsForForegroundServiceScanning()
 46 | 
 47 |         // This line below will apply the new beacon scanning settings immediately  Any individual
 48 |         // settings not specified on the new settings object will revert to defaults.
 49 |         // If you only want to make a partial change to the settings, without reverting to defaults
 50 |         // for any settings unspecified you may call `beaconManager.adjustSettings(settings)`
 51 |         //beaconManager.replaceSettings(settings)
 52 |         //beaconManager.adjustSettings(Settings(debug = true))
 53 | 
 54 |         // The code below will start "monitoring" and "ranging" for beacons matching the region
 55 |         // definition at the top of this file
 56 | 
 57 |         beaconManager.startMonitoring(wildcardIBeaconRegion)
 58 |         beaconManager.startRangingBeacons(wildcardIBeaconRegion)
 59 | 
 60 |         // Set up a Live Data observer so this Activity can get beacon data from the Application class
 61 |         val regionViewModel = BeaconManager.getInstanceForApplication(this).getRegionViewModel(wildcardIBeaconRegion)
 62 |         // observer will be called each time the monitored regionState changes (inside vs. outside region)
 63 |         regionViewModel.regionState.observeForever( centralMonitoringObserver)
 64 |         // observer will be called each time a new list of beacons is ranged (typically ~1 second in the foreground)
 65 |         regionViewModel.rangedBeacons.observeForever( centralRangingObserver)
 66 |     }
 67 | 
 68 |     fun getSettingsForForegroundServiceScanning(): Settings {
 69 | 
 70 |         val builder = Notification.Builder(this, "BeaconReferenceApp")
 71 |         builder.setSmallIcon(R.drawable.ic_launcher_background)
 72 |         builder.setContentTitle("Scanning for Beacons")
 73 |         val intent = Intent(this, MainActivity::class.java)
 74 |         val pendingIntent = PendingIntent.getActivity(
 75 |             this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT + PendingIntent.FLAG_IMMUTABLE
 76 |         )
 77 |         builder.setContentIntent(pendingIntent);
 78 |         val channel =  NotificationChannel("beacon-ref-notification-id",
 79 |             "My Notification Name", NotificationManager.IMPORTANCE_DEFAULT)
 80 |         channel.description = "My Notification Channel Description"
 81 |         val notificationManager =  getSystemService(
 82 |             Context.NOTIFICATION_SERVICE) as NotificationManager
 83 |         notificationManager.createNotificationChannel(channel)
 84 |         builder.setChannelId(channel.id)
 85 |         val notification = builder.build()
 86 | 
 87 |         return Settings(
 88 |             scanStrategy = Settings.ForegroundServiceScanStrategy(
 89 |                 notification, 456
 90 |             ),
 91 |             scanPeriods = Settings.ScanPeriods(1100, 0, 1100, 0),
 92 |             longScanForcingEnabled = true
 93 |         )
 94 |     }
 95 | 
 96 |     private val centralMonitoringObserver = Observer<Int> { state ->
 97 |         if (state == MonitorNotifier.OUTSIDE) {
 98 |             Log.d(TAG, "outside beacon region.")
 99 |         }
100 |         else {
101 |             Log.d(TAG, "inside beacon region.")
102 |             sendNotification()
103 |         }
104 |     }
105 | 
106 |     private val centralRangingObserver = Observer<Collection<Beacon>> { beacons ->
107 |         val rangeAgeMillis = System.currentTimeMillis() - (beacons.firstOrNull()?.lastCycleDetectionTimestamp ?: 0)
108 |         if (rangeAgeMillis < 10000) {
109 |             Log.d(MainActivity.TAG, "Ranged: ${beacons.count()} beacons")
110 |             for (beacon: Beacon in beacons) {
111 |                 Log.d(TAG, "$beacon about ${beacon.distance} meters away")
112 |             }
113 |         }
114 |         else {
115 |             Log.d(MainActivity.TAG, "Ignoring stale ranged beacons from $rangeAgeMillis millis ago")
116 |         }
117 |     }
118 | 
119 |     private fun sendNotification() {
120 |         val builder = NotificationCompat.Builder(this, "beacon-ref-notification-id")
121 |             .setContentTitle("Beacon Reference Application")
122 |             .setContentText("A beacon is nearby.")
123 |             .setSmallIcon(R.drawable.ic_launcher_background)
124 |         val stackBuilder = TaskStackBuilder.create(this)
125 |         stackBuilder.addNextIntent(Intent(this, MainActivity::class.java))
126 |         val resultPendingIntent = stackBuilder.getPendingIntent(
127 |             0,
128 |             PendingIntent.FLAG_UPDATE_CURRENT + PendingIntent.FLAG_IMMUTABLE
129 |         )
130 |         builder.setContentIntent(resultPendingIntent)
131 |         val channel =  NotificationChannel("beacon-ref-notification-id",
132 |             "My Notification Name", NotificationManager.IMPORTANCE_DEFAULT)
133 |         channel.setDescription("My Notification Channel Description")
134 |         val notificationManager =  getSystemService(
135 |             Context.NOTIFICATION_SERVICE) as NotificationManager
136 |         notificationManager.createNotificationChannel(channel);
137 |         builder.setChannelId(channel.getId());
138 |         notificationManager.notify(1, builder.build())
139 |     }
140 | 
141 |     companion object {
142 |         const val TAG = "BeaconReference"
143 |     }
144 | 
145 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright 2014-2018 Radius Networks
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/app/src/main/java/org/altbeacon/beacon/permissions/PermissionsActivity.kt:
--------------------------------------------------------------------------------
  1 | package org.altbeacon.beacon.permissions
  2 | 
  3 | import android.Manifest
  4 | import android.annotation.SuppressLint
  5 | import android.app.AlertDialog
  6 | import android.content.Context
  7 | import android.content.pm.PackageManager
  8 | import android.graphics.Color
  9 | import android.os.Build
 10 | import android.os.Bundle
 11 | import android.util.Log
 12 | import android.view.Gravity
 13 | import android.view.View
 14 | import android.widget.Button
 15 | import android.widget.LinearLayout
 16 | import android.widget.TextView
 17 | import androidx.activity.result.contract.ActivityResultContracts
 18 | import androidx.appcompat.app.AppCompatActivity
 19 | import androidx.core.content.ContextCompat
 20 | import androidx.core.view.setPadding
 21 | 
 22 | open class PermissionsActivity: AppCompatActivity() {
 23 | 
 24 |     val requestPermissionsLauncher =
 25 |         registerForActivityResult(
 26 |             ActivityResultContracts.RequestMultiplePermissions()
 27 |         ) { permissions ->
 28 |             // Handle Permission granted/rejected
 29 |             permissions.entries.forEach {
 30 |                 val permissionName = it.key
 31 |                 val isGranted = it.value
 32 |                 if (isGranted) {
 33 |                     Log.d(TAG, "$permissionName permission granted: $isGranted")
 34 |                     // Permission is granted. Continue the action or workflow in your
 35 |                     // app.
 36 |                 } else {
 37 |                     Log.d(TAG, "$permissionName permission granted: $isGranted")
 38 |                     // Explain to the user that the feature is unavailable because the
 39 |                     // features requires a permission that the user has denied. At the
 40 |                     // same time, respect the user's decision. Don't link to system
 41 |                     // settings in an effort to convince the user to change their
 42 |                     // decision.
 43 |                 }
 44 |             }
 45 |         }
 46 | 
 47 |     companion object {
 48 |         const val TAG = "PermissionsActivity"
 49 |     }
 50 | }
 51 | 
 52 | class PermissionsHelper(val context: Context) {
 53 |     // Manifest.permission.ACCESS_BACKGROUND_LOCATION
 54 |     // Manifest.permission.ACCESS_FINE_LOCATION
 55 |     // Manifest.permission.BLUETOOTH_CONNECT
 56 |     // Manifest.permission.BLUETOOTH_SCAN
 57 |     fun isPermissionGranted(permissionString: String): Boolean {
 58 |         return (ContextCompat.checkSelfPermission(context, permissionString) == PackageManager.PERMISSION_GRANTED)
 59 |     }
 60 |     fun setFirstTimeAskingPermission(permissionString: String, isFirstTime: Boolean) {
 61 |         val sharedPreference = context.getSharedPreferences("org.altbeacon.permisisons",
 62 |             AppCompatActivity.MODE_PRIVATE
 63 |         )
 64 |         sharedPreference.edit().putBoolean(permissionString,
 65 |             isFirstTime).apply()
 66 |     }
 67 | 
 68 |     fun isFirstTimeAskingPermission(permissionString: String): Boolean {
 69 |         val sharedPreference = context.getSharedPreferences(
 70 |             "org.altbeacon.permisisons",
 71 |             AppCompatActivity.MODE_PRIVATE
 72 |         )
 73 |         return sharedPreference.getBoolean(
 74 |             permissionString,
 75 |             true
 76 |         )
 77 |     }
 78 |     fun beaconScanPermissionGroupsNeeded(backgroundAccessRequested: Boolean = false): List<Array<String>> {
 79 |         val permissions = ArrayList<Array<String>>()
 80 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 81 |             // As of version M (6) we need FINE_LOCATION (or COARSE_LOCATION, but we ask for FINE)
 82 |             permissions.add(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION))
 83 |         }
 84 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 85 |             // As of version Q (10) we need FINE_LOCATION and BACKGROUND_LOCATION
 86 |             if (backgroundAccessRequested) {
 87 |                 permissions.add(arrayOf(Manifest.permission.ACCESS_BACKGROUND_LOCATION))
 88 |             }
 89 |         }
 90 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
 91 |             // As of version S (12) we need FINE_LOCATION, BLUETOOTH_SCAN and BACKGROUND_LOCATION
 92 |             // Manifest.permission.BLUETOOTH_CONNECT is not absolutely required to do just scanning,
 93 |             // but it is required if you want to access some info from the scans like the device name
 94 |             // and the aditional cost of requsting this access is minimal, so we just request it
 95 |             permissions.add(arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT, Manifest.permission.BLUETOOTH_ADVERTISE))
 96 |         }
 97 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
 98 |             // As of version nonBeaconBeaconRegionT (13) we POST_NOTIFICATIONS permissions if using a foreground service
 99 |             permissions.add(arrayOf(Manifest.permission.POST_NOTIFICATIONS))
100 |         }
101 |         return permissions
102 |     }
103 | 
104 | }
105 | 
106 | 
107 | 
108 | open class BeaconScanPermissionsActivity: PermissionsActivity()  {
109 |     lateinit var layout: LinearLayout
110 |     lateinit var permissionGroups: List<Array<String>>
111 |     lateinit var continueButton: Button
112 |     var scale: Float = 1.0f
113 |         get() {
114 |             return this.getResources().getDisplayMetrics().density
115 |         }
116 | 
117 |     override fun onCreate(savedInstanceState: Bundle?) {
118 |         super.onCreate(savedInstanceState)
119 | 
120 |         layout = LinearLayout(this)
121 |         layout.setPadding(dp(20))
122 |         layout.gravity = Gravity.CENTER
123 |         layout.setBackgroundColor(Color.WHITE)
124 |         layout.orientation = LinearLayout.VERTICAL
125 |         val backgroundAccessRequested = intent.getBooleanExtra("backgroundAccessRequested", true)
126 |         val title = intent.getStringExtra("title") ?: "Permissions Needed"
127 |         val message = intent.getStringExtra("message") ?: "In order to scan for beacons, this app requrires the following permissions from the operating system.  Please tap each button to grant each required permission."
128 |         val continueButtonTitle = intent.getStringExtra("continueButtonTitle") ?: "Continue"
129 |         val permissionButtonTitles = intent.getBundleExtra("permissionBundleTitles") ?: getDefaultPermissionTitlesBundle()
130 | 
131 |         permissionGroups = PermissionsHelper(this).beaconScanPermissionGroupsNeeded(backgroundAccessRequested)
132 | 
133 |         val params = LinearLayout.LayoutParams(
134 |             LinearLayout.LayoutParams.MATCH_PARENT,
135 |             LinearLayout.LayoutParams.WRAP_CONTENT
136 |         )
137 |         params.setMargins(dp(0), dp(10), dp(0), dp(10))
138 | 
139 | 
140 |         val titleView = TextView(this)
141 |         titleView.setGravity(Gravity.CENTER)
142 |         titleView.textSize = dp(10).toFloat()
143 |         titleView.text = title
144 |         titleView.layoutParams = params
145 | 
146 |         layout.addView(titleView)
147 |         val messageView = TextView(this)
148 |         messageView.text = message
149 |         messageView.setGravity(Gravity.CENTER)
150 |         messageView.textSize = dp(5).toFloat()
151 |         messageView.textAlignment = TextView.TEXT_ALIGNMENT_CENTER
152 |         messageView.layoutParams = params
153 |         layout.addView(messageView)
154 | 
155 |         var index = 0
156 |         for (permissionGroup in permissionGroups) {
157 |             val button = Button(this)
158 |             val buttonTitle = permissionButtonTitles.getString(permissionGroup.first())
159 |             button.id = index
160 |             button.text = buttonTitle
161 |             button.layoutParams = params
162 |             button.setOnClickListener(buttonClickListener)
163 |             layout.addView(button)
164 |             index += 1
165 |         }
166 | 
167 |         continueButton = Button(this)
168 |         continueButton.text = continueButtonTitle
169 |         continueButton.isEnabled = false
170 |         continueButton.setOnClickListener {
171 |             this.finish()
172 |         }
173 |         continueButton.layoutParams = params
174 |         layout.addView(continueButton)
175 | 
176 |         setContentView(layout)
177 |     }
178 | 
179 |     fun dp(value: Int): Int {
180 |         return (value * scale + 0.5f).toInt()
181 |     }
182 | 
183 |     val buttonClickListener = View.OnClickListener { button ->
184 |         val permissionsGroup = permissionGroups.get(button.id)
185 |         promptForPermissions(permissionsGroup)
186 |     }
187 | 
188 |     @SuppressLint("InlinedApi")
189 |     fun getDefaultPermissionTitlesBundle(): Bundle {
190 |         val bundle = Bundle()
191 |         bundle.putString(Manifest.permission.ACCESS_FINE_LOCATION, "Location")
192 |         bundle.putString(Manifest.permission.ACCESS_BACKGROUND_LOCATION, "Background Location")
193 |         bundle.putString(Manifest.permission.BLUETOOTH_SCAN, "Bluetooth")
194 |         bundle.putString(Manifest.permission.POST_NOTIFICATIONS, "Notifications")
195 |         return bundle
196 |     }
197 | 
198 | 
199 |     fun allPermissionGroupsGranted(): Boolean {
200 |         for (permissionsGroup in permissionGroups) {
201 |             if (!allPermissionsGranted(permissionsGroup)) {
202 |                 return false
203 |             }
204 |         }
205 |         return true
206 |     }
207 | 
208 |     fun setButtonColors() {
209 |         var index = 0
210 |         for (permissionsGroup in this.permissionGroups) {
211 |             val button = findViewById<Button>(index)
212 |             if (allPermissionsGranted(permissionsGroup)) {
213 |                 button.setBackgroundColor(Color.parseColor("#448844"))
214 |             }
215 |             else {
216 |                 button.setBackgroundColor(Color.RED)
217 |             }
218 |             index += 1
219 |         }
220 |     }
221 |     override fun onResume() {
222 |         super.onResume()
223 |         setButtonColors()
224 |         if (allPermissionGroupsGranted()) {
225 |             continueButton.isEnabled = true
226 |         }
227 |     }
228 | 
229 |     fun promptForPermissions(permissionsGroup: Array<String>) {
230 |         if (!allPermissionsGranted(permissionsGroup)) {
231 |             val firstPermission = permissionsGroup.first()
232 | 
233 |             var showRationale = true
234 |             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
235 |                 showRationale = shouldShowRequestPermissionRationale(firstPermission)
236 |             }
237 |             if (showRationale ||  PermissionsHelper(this).isFirstTimeAskingPermission(firstPermission)) {
238 |                 PermissionsHelper(this).setFirstTimeAskingPermission(firstPermission, false)
239 |                 requestPermissionsLauncher.launch(permissionsGroup)
240 |             }
241 |             else {
242 |                 val builder = AlertDialog.Builder(this)
243 |                 builder.setTitle("Can't request permission")
244 |                 builder.setMessage("This permission has been previously denied to this app.  In order to grant it now, you must go to Android Settings to enable this permission.")
245 |                 builder.setPositiveButton("OK", null)
246 |                 builder.show()
247 |             }
248 |         }
249 |     }
250 |     fun allPermissionsGranted(permissionsGroup: Array<String>): Boolean {
251 |         val permissionsHelper = PermissionsHelper(this)
252 |         for (permission in permissionsGroup) {
253 |             if (!permissionsHelper.isPermissionGranted(permission)) {
254 |                 return false
255 |             }
256 |         }
257 |         return true
258 |     }
259 | 
260 |     companion object {
261 |         const val TAG = "BeaconScanPermissionActivity"
262 |         fun allPermissionsGranted(context: Context, backgroundAccessRequested: Boolean): Boolean {
263 |             val permissionsHelper = PermissionsHelper(context)
264 |             val permissionsGroups = permissionsHelper.beaconScanPermissionGroupsNeeded(backgroundAccessRequested)
265 |             for (permissionsGroup in permissionsGroups) {
266 |                 for (permission in permissionsGroup) {
267 |                     if (!permissionsHelper.isPermissionGranted(permission)) {
268 |                         return false
269 |                     }
270 |                 }
271 |             }
272 |             return true
273 |         }
274 |     }
275 | }
276 | 


--------------------------------------------------------------------------------