Github Packages

Create a Personal Access Token on Github

Inside your GitHub Account:

1. Go to Settings -> Developer Settings -> Personal Access Tokens -> Generate new token

2. Make sure to select the scope read:packages and Generate a token

3. After the token is generated, be sure to copy your new personal access token. It will not be accessible again. If the key is lost, the only option is to generate a new key.

Configure your Github Personal Access Token

To configure your token, a github.properties file containing your Github User ID and Personal Access Token must be placed in your project's root directory as shown below:

gpr.user=GITHUB_USERID
gpr.key=PERSONAL_ACCESS_TOKEN

Alternatively, you can set the environment variables GPR_USER and GPR_API_KEY.

Add Github Packages Repository to Application Module's build.gradle

Next, define the Github Packages as a repository in the application module's build.gradle by adding the following section:

def githubProperties = new Properties() githubProperties.load(new FileInputStream(rootProject.file("github.properties")))
repositories {
    maven {
        name = "GitHubPackages"
        url = uri("https://maven.pkg.github.com/snapodds/sdk-android")
        
        credentials {        
            /** Create github.properties in root project folder file with     
            ** gpr.usr=GITHUB_USER_ID & gpr.key=PERSONAL_ACCESS_TOKEN 
            ** Or set env variable GPR_USER & GPR_API_KEY if not adding a properties file**/
            username = githubProperties['gpr.usr'] ?: System.getenv("GPR_USER")
            password = githubProperties['gpr.key'] ?: System.getenv("GPR_API_KEY")
        }

        metadataSources {
            mavenPom()
            google()
            mavenCentral()
            artifact()
        }
    }
}

Add Dependency to Snapscreen SDK in Application Module's build.gradle

dependencies {
    //consume library
    implementation 'com.snapscreen.mobile:sdk-android:latest-release'
}

SnapOdds Operator provides you with the Snapping UI for Snapping Sport Events and returns you all required information about the sport event. After a successful snap you are free to use the result as you wish and present subsequent functionality to the user.

Snapscreen uses various Android permissions to function correctly. Each of the permissions listed below are necessary, (and automatically defined by the Snapscreen SDK):

android.permission.INTERNET
Used for accessing the backend services of Snapscreen

android.permission.CAMERA
Used for offering snapping functionality and access to the camera

android.permission.VIBRATE
Used for device feedback during snapping functionality

Customizing Colors

To customize colors in SnapFragment use the UIColorConfiguration object on the Snapscreen instance.

Snapscreen.instance?.colorConfiguration.background = R.color.myBackground

Customizing Fonts

To customize fonts in SnapFragment, use the UIFontConfiguration object on the Snapscreen instance.

Snapscreen.instance?.fontConfiguration.baseTypeface = Typeface.DEFAULT

Customizing Snap UI

To customize displayed messages in the SnapFragment use the SnapUIConfiguration object on the Snapscreen instance.

Snapscreen.instance?.snapUIConfiguration.snapHintText = "My custom Hint"

All desired customizations must be done prior to presenting the SnapFragment or SnapActivity. While it is possible to modify the configuration between presentations of the SnapFragment, such modifications while SnapFragment is present are not guaranteed to be respected.

The following section deals primarily with the code used in capture of live game information for SnapOdds Operator. If your use case requires game odds to be presented, the information captured by SnapOdds Operator is fed into SnapOdds Sports Media to correlate the game odds information, as described in Snapping Games and Presenting Odds

Implementation

1. Ensure the SDK is initialized according to instructions listed in the Android Initialization section.

2. Ensure your class conforms to SnapFragmentResultListener or SnapActivityResultListener

3. Instantiate SnapFragment or SnapActivity with your desired SnapConfiguration and your SnapFragmentResultListener or SnapActivityResultListener

4. Handle the result in your listener implementation.

Live Game Capture Code Example

In order to snap a TV image and search for a sporting event, it is necessary to create and present an instance of SnapFragment via the newInstance class method. Snap settings can be customized by configuring the SnapConfiguration passed to the initializer. The SnapFragmentResultListener will receive a callback once a sporting event was successfully snapped.

The following code presents a SnapFragment with the default configuration.

SnapFragment.newInstance(SnapConfiguration(), this)

If you do not want or need to customize the snapping configuration, you can also omit the configuration parameter.

Once a sporting event is successfully 'snapped', the following method is called in SnapFragmentResultListener:

override fun snapFragmentDidSnapSportEvent(
        fragment: SnapFragment,
        sportEvent: SportEventSnapResultEntry
    ) {
    // This is the SportRadar Match ID by default. 
    // Other ID providers are available on request
    val externalProviderId = sportEvent.externalId
}

After a successfull snap (and call of the listener method) the SnapFragment automatically stops snapping. If you do not present any follow-up UI and you want to continue snapping, you can call continueSnapping() on the SnapFragment.

If the sporting event is not successfully snapped, the values above are not returned, and an error message will appear in the viewfinder: "Your snap returned no results. Make sure your TV is visible in the viewfinder"

Camera Permissions Required before Presenting Snap

Applications must request user permission for camera access, and camera access is required for the app to function. For this reason, your application should be set to ask permission from the user to access the camera, and to receive said permission, before presenting the Snap UI. The following code will set your application to request and receive permission prior to opening Snap UI:

val isGranted = ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
if (isGranted) {
    startActivity(Intent(context, MySnapActivity::class.java))
} else {
    requestPermissions(arrayOf(Manifest.permission.CAMERA), PERMISSION_REQUEST_CAMERA)
}

Alternative Example using SnapActivity

In addition to using the SnapFragment directly, you can also use the SnapActivity provided by the SDK. In that case, use the class method on SnapActivity to retrieve an intent and pass a SnapActivityResultListener. The SnapActivityResultListener will receive a callback once a sporting event was successfully snapped.

The following code presents a SnapActivity with the default configuration.

val intent = SnapActivity.intentForSportsOperator(this, SnapConfiguration(), this)
startActivity(intent)

If you do not want or need to customize the snapping configuration, you can also omit the configuration parameter.

Once a sporting event is successfully snapped, the following method is called in SnapActivityResultsListener:

override fun snapActivityDidSnapSportEvent(
    activity: SnapActivity,
    fragment: SnapFragment,
    sportEvent: SportEventSnapResultEntry) {
    
}

After a successfull snap (and call of the listener method) the SnapFragment (used for UI presentation in the SnapActivity) automatically stops snapping. If you do not present any follow-up UI and you want to continue snapping, you can call continueSnapping() on the SnapFragment.

If you want to dismiss the activity and continue your own UI, you need to call activity.finish() on the SnapActivity.

Recommendations

Present Snap as a separate Activity

It is recommended that you present the SnapFragment as a separate Activity.

Limit to portrait

Currently the Snap UI is only optimized for portrait orientation. It is recommended to present and limit the Activity containing a SnapFragment be limited to portrait orientation.

Initialization

In order to initialize Snapscreen, the following class method must be called in your custom Application class in onCreate()

class MyApplication: Application() {
    
    override fun onCreate() {
        super.onCreate()

        Snapscreen.setup(
            this, 
            "your-client-id", 
            "your-client-secret", 
            Environment.PRODUCTION
        )
    }
}

Additional Information

For best results, locational information must be provided for the user on initialization. Within the SDK, set the users country and US state information using the parameters country and usState. For US customers, country and state information must be provided. For non-US customers, at least country should be provided.

Snapscreen.instance?.country = "US"
Snapscreen.instance?.usState = "NJ"

Accessing SDK Instance

Once Snapscreen has been initialized, it can be retrieved by calling:

Snapscreen.instance