Google Analytics Android integráció az Android Studio használatával

Új Analytics-tulajdon létrehozásához jelentkezzen be a Google Analytics-fiókba a Google Fiókjával.

Válassza az Adminisztráció lapot, és kattintson a Fiók › Új fiók létrehozása lehetőségre. Abban az esetben, ha már rendelkezik kívánt fiókkal, válassza ki azt, és hozzon létre egy tulajdont.

Válassza a Mobilalkalmazás lapot, és adja meg az Alkalmazás nevét.

Kattintson az alábbi Követőazonosító lekérése gombra.

Most egy nyomkövetési azonosítót fog kapni, amely a következő formátumú lesz: UA-XXXXXXXX-X

2. A Google Analytics Android oktatóprogram létrehozása és a szükséges kód hozzáadása:

Most hozzuk létre a projektet. Nyissa meg az Android Studio-t, és kattintson a Fájl › Minden projekt bezárása elemre.

Most kattintson az Új Android Studio projekt létrehozása lehetőségre, és kattintson a Tovább gombra. Itt a projektemet Google Analytics Android oktatóanyagnak neveztem el.

Töltse ki az összes szükséges adatot. Válassza az Üres tevékenység lehetőséget az Android Studio ‹1.4-es verziója esetén (vagy az Üres tevékenység lehetőséget az Android Studio ›1.4-es verziója esetén).

A projekt létrehozásával kapcsolatos további információkért tekintse meg a következő cikket:

"Kezdő lépések az Android Studio használatával az első projekt létrehozásával"

a. Szükséges engedélyek hozzáadása:

Az Analytics Android Stúdióba való integrálásához a következő szükséges engedélyeket kell hozzáadnunk a Google Analytics Android oktatóanyag jegyzékfájljához:

<uses-permission android:name = “android.permission.INTERNET”/>
<uses-permission android:name = “android.permission.ACCESS_NETWORK_STATE”/>

b. Függőségek és beépülő modulok hozzáadása:

Az Analytics működéséhez hozzá kell adnunk a függőségeket és a beépülő modulokat az Android Studio build.gradle fájljához.

Először állítsa be a projektet Android nézetre. Válassza ki a Project's build.gradle fájlt, és adja hozzá a következő kódrészletet:

classpath 'com.google.gms:google-services:1.4.0-beta3'

A projekt build.gradle fájlja szintén felső szintű build.gradle fájlnak minősül. Győződjön meg róla, hogy hozzáadta a fenti kódot a Project build.gradle fájljához.

Most nyissa meg az app build.gradle fájlját, és adja hozzá a következő kódot:

apply plugin: 'com.google.gms.google-services'

Az app build.gradle fájljának Függőségek szakaszában adja hozzá a következő kódot:

compile 'com.google.android.gms:play-services-analytics:8.1.0'

Megjegyzés: A Google mindig frissíti a Google szolgáltatások, a Play szolgáltatások elemzési verzióját. Míg a fenti kód működik, annak érdekében, hogy mindig a legfrissebb kódot használja, tekintse meg a kódot az e linkben.

Most az alkalmazás build.gradle fájlja a következőképpen fog kinézni:

apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'
android {
    compileSdkVersion 23
    buildToolsVersion "23.0.1"
defaultConfig {
        applicationId "com.coderefer.googleanalyticsandroidtutorial"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.0.1'
    compile 'com.google.android.gms:play-services-analytics:8.1.0'
    compile 'com.android.support:design:23.0.1'
}

Now we need to add google-services.json file in our project in order to add analytics. To get the file, click this link and Give your app name and project name.

Now Click on Choose and Configure Services.
Here you can add the services such as Analytics, Google + Integration, Google Cloud Messaging Services etc. Since this tutorial is focused on Google Analytics, let us just configure the file for Google Analytics.
Now click on Analytics logo and fill the details below. You need a Google Analytics in order to configure the service below. Since we covered this in our first step, let us select the property created in our analytics. Now click on Enable Analytics Service.
[widget id="text-3"]
Now scroll down and Click on Generate Configuration Files.
Now you can download the json file. Copy the file and Paste it in the app folder of your project. It will be generally:
C:\Users\<USERNAME>\AndroidStudioProjects\GoogleAnalyticsAndroidTutorial\app
c. Creating and Configuring XML file:
Now create an xml file named analytics_tracker.xml in res > xml folder of our Google Analytics Android Tutorial Project to use it as a custom Analytics Configuration File. If xml folder doesnot exist, create a folder named xml. Now add the following code in the newly created analytics_tracker.xml file:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="ga_trackingId">UA-XXXXXXXX-X</string>
    <bool name="ga_reportUncaughtExceptions">true</bool>
</resources>
Note: Make  sure you replace the tracking Id in the code above with your tracking Id generated in the Step 1. Otherwise, tracking Will NOT work.
d. Adding required additional String Resources:
Before going any further, let us add required additional String resource files.
<string name="app_name">Google Analytics Android Tutorial</string>
    <string name="title_activity_next_screen">Next Screen</string>
    <string name="my_fragment">This is a Fragment! Tap Fragment Button again to remove this Fragment from this Activity</string>
    <string name="categoryId">Purchase</string>
    <string name="actionId">Buy Tickets</string>
    <string name="labelId">Buy Tickets Button Pressed!</string>

e. Osztály létrehozása, amely kiterjeszti az alkalmazást:

We will now add a Class with name GoogleAnalyticsApplication.java to our Google Analytics Android Tutorial Project which will extend Application Class from android.app package.
We will now add the following code to our class:
package com.coderefer.googleanalyticsandroidtutorial;
import android.app.Application;
import com.google.android.gms.analytics.GoogleAnalytics;
import com.google.android.gms.analytics.Tracker;
/**
 * Created by Vamsi Tallapudi on 24-Oct-15.
 */
public class GoogleAnalyticsApplication extends Application {
private Tracker mTracker;
/**
     * Gets the default {@link Tracker} for this {@link Application}.
     * @return tracker
     */
    synchronized public Tracker getDefaultTracker() {
        if (mTracker == null) {
            GoogleAnalytics analytics = GoogleAnalytics.getInstance(this);
            // Setting mTracker to Analytics Tracker declared in our xml Folder
            mTracker = analytics.newTracker(R.xml.analytics_tracker);
        }
        return mTracker;
    }
}

We now open AndroidManifest.xml and add application name as follows:
android:name=".GoogleAnalyticsApplication"
Now our Manifest file will now look as follows:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.coderefer.googleanalyticsandroidtutorial" >
<uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<application
        android:name=".GoogleAnalyticsApplication"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".MainActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".NextScreen"
            android:label="@string/title_activity_next_screen"
            android:parentActivityName=".MainActivity"
            android:theme="@style/AppTheme.NoActionBar" >
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value="com.coderefer.googleanalyticsandroidtutorial.MainActivity" />
        </activity>
    </application>
</manifest>
f. Modifying activity_main.xml
First we will modify our activity_main.xml by adding the following code:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#400000FA"
    android:paddingTop="@dimen/activity_horizontal_margin"
    tools:context=".MainActivity">
<LinearLayout
        android:layout_alignParentTop="true"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:layout_above="@+id/container"
        android:weightSum="5">
<Button
            android:id="@+id/bNextScreen"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center_horizontal"
            android:layout_margin="20dp"
            android:layout_weight="1"
            android:background="#80ffffff"
            android:text="Next Screen (Activity Tracking)"
            android:textColor="#FF4081" />
<Button
            android:id="@+id/bFragment"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center_horizontal"
            android:layout_margin="20dp"
            android:layout_weight="1"
            android:background="#80ffffff"
            android:text="Fragment Tracking"
            android:textColor="#FF4081" />
<Button
            android:id="@+id/bEvent"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center_horizontal"
            android:layout_margin="20dp"
            android:layout_weight="1"
            android:background="#80ffffff"
            android:text="Event Tracking"
            android:textColor="#FF4081" />
<Button
            android:id="@+id/bException"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center_horizontal"
            android:layout_margin="20dp"
            android:layout_weight="1"
            android:background="#80ffffff"
            android:text="Exception Tracking"
            android:textColor="#FF4081" />
<Button
            android:id="@+id/bCrashApp"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center_horizontal"
            android:layout_margin="20dp"
            android:layout_weight="1"
            android:background="#80ffffff"
            android:text="Crash Tracking"
            android:textColor="#FF4081" />
</LinearLayout>
<FrameLayout
        android:padding="10dp"
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true" />
</RelativeLayout>
3. Tracking an Activity:
We will now discuss about how to track an Activity using Google Analytics by implementing the code in our MainActivity.java.
[widget id="text-3"]
To track Activities/Screens, we use ScreenViewBuilder() method from HitBuilders Class to send Screen to Google Analytics Android.
Open MainActivity.java and add the Tracker variable:
Private Tracker mTracker
Now add this piece of code in onCreate() method:
//Analytics Integration
// Obtain the shared Tracker instance.
GoogleAnalyticsApplication application = (GoogleAnalyticsApplication) getApplication();
mTracker = application.getDefaultTracker();
Now we need to override onResume() method to declare the following code:
@Override
    protected void onResume() {
        super.onResume();
        mTracker.setScreenName(“Main Screen”);
        mTracker.send(new HitBuilders.ScreenViewBuilder().build());
    }
We will also wire up the buttons in our MainActivity.java and add the code to our NextScreen Button Variable so that it can Start Next Activity/Screen. Now the MainActivity.java will look as follows:
package com.coderefer.googleanalyticsandroidtutorial;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import com.google.android.gms.analytics.HitBuilders;
import com.google.android.gms.analytics.StandardExceptionParser;
import com.google.android.gms.analytics.Tracker;
public class MainActivity extends AppCompatActivity {
private static final String TAG = MainActivity.class.getSimpleName();
    private Tracker mTracker;
    String name = new String("Main Screen");
    static Boolean toggle = false;
@Override
    protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
//Analytics Integration
        // Obtain the shared Tracker instance.
        GoogleAnalyticsApplication application = (GoogleAnalyticsApplication) getApplication();
        mTracker = application.getDefaultTracker();
Button bNextScreen = (Button) findViewById(R.id.bNextScreen);
        Button bFragment = (Button) findViewById(R.id.bFragment);
        Button bEvent = (Button) findViewById(R.id.bEvent);
        Button bException = (Button) findViewById(R.id.bException);
        Button bCrashApp = (Button) findViewById(R.id.bCrashApp);
//Starts Next Activity/Screen
        bNextScreen.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent i = new Intent(MainActivity.this, NextScreen.class);
                startActivity(i);
            }
        });
}
@Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "Setting screen name: " + name);
        //using tracker variable to set Screen Name
        mTracker.setScreenName(name);
        //sending the screen to analytics using ScreenViewBuilder() method
        mTracker.send(new HitBuilders.ScreenViewBuilder().build());
    }
}

To track Next Screen also, create NextScreen.java and add the following code:
package com.coderefer.googleanalyticsandroidtutorial;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.View;
import com.google.android.gms.analytics.HitBuilders;
import com.google.android.gms.analytics.Tracker;
public class NextScreen extends AppCompatActivity {
private static final String TAG = NextScreen.class.getSimpleName();
    private Tracker mTracker;
    private String name = "Next Screen";
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_next_screen);
//Analytics Integration
        // Obtain the shared Tracker instance.
        GoogleAnalyticsApplication application = (GoogleAnalyticsApplication) getApplication();
        mTracker = application.getDefaultTracker();
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    }
@Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "Setting screen name: " + name);
        mTracker.setScreenName(name);
        mTracker.send(new HitBuilders.ScreenViewBuilder().build());
    }
}
Now you can successfully run the app and switch between Activities. You also can successfully track your app in Google Analytics Dashboard.
Important Note: It will usually takes 1-3 minutes for Google Analytics to track your Activity/screen in Real time.
The following image shows the real time Tracking of this app with the screen Name main screen:

4. Tracking A Fragment :
Tracking a Fragment is very similar to Tracking an Activity. Here, We use the same method, i.e., ScreenViewBuilder() method from HitBuilders class in our Fragment’s onResume() method to track the fragment in Google Analytics Android. Let us now create a Fragment and Add it to our MainActivity. Let us name the Fragment class as FragmentDemo.java and add the following code to it:
package com.coderefer.googleanalyticsandroidtutorial;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.google.android.gms.analytics.HitBuilders;
import com.google.android.gms.analytics.Tracker;
/**
 * Created by Vamsi Tallapudi on 24-Oct-15.
 */
public class FragmentDemo extends Fragment {
private static final String TAG = FragmentDemo.class.getSimpleName();
    private Tracker mTracker;
    String name = new String("Fragment Demo");
public FragmentDemo(){
}
@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
GoogleAnalyticsApplication application = (GoogleAnalyticsApplication) getActivity().getApplication();
        mTracker = application.getDefaultTracker();
}
@Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.my_fragment, container, false);
    }
@Override
    public void onResume() {
        super.onResume();
        Log.i(TAG, "Setting screen name: " + name);
        mTracker.setScreenName(name);
        mTracker.send(new HitBuilders.ScreenViewBuilder().build());
}
}

The above code inflates my_fragment.xml file. Now open my_fragment.xml file and add the following code to it:
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.coderefer.googleanalyticsandroidtutorial.FragmentDemo">
<TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/my_fragment"
        android:background="@color/colorAccent"
        android:textColor="#ffffff"
        android:textAlignment="center"
        android:gravity="center"
        android:textSize="15dp"
        android:layout_margin="20dp"/>
</FrameLayout>
Since we already added a Frame Layout in our activity_main.xml file, the above fragment can be inflated in our activity_main.xml file.
To inflate and remove this Fragment in our MainActivity.xml file, we will add the following code to our Fragment Button variable bFragment in our onCreate() method:
bFragment.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
FragmentManager fragmentManager = getSupportFragmentManager();
                FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
                Fragment myFragment = (Fragment) fragmentManager.findFragmentByTag("TAG_FRAGMENT");
                if (myFragment == null) {
myFragment = new FragmentDemo();
fragmentTransaction.replace(R.id.container, myFragment, "TAG_FRAGMENT");
                    fragmentTransaction.commit();
} else {
                    fragmentTransaction.remove(myFragment).commit();
}
}
        });
5. Event Tracking:
Event Tracking is used to Track any events such as Button Clicks, Downloads, Item Purchases, Tracking of any items in a Game such as Level Completion, in-app Purchases, Power ups, etc.
To track an Event, we use EventBuilder() method from HitBuilder class to Track Events in Google Analytics.
In this Tutorial, Let us suppose that we want to Track the Purchase of a Movie Ticket. Let us Register that event in our Google Analytics Account from our Google Analytics Android Tutorial App.
Here is the code we need to add in our Main Activity’s onCreate Method so that when user presses button, Event will be registered:
bEvent.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        // Get tracker.
        Tracker t = ((GoogleAnalyticsApplication) getApplication()).getDefaultTracker();
// Build and send an Event.
        t.send(new HitBuilders.EventBuilder()
                .setCategory(getString(R.string.categoryId))
                .setAction(getString(R.string.actionId))
                .setLabel(getString(R.string.labelId))
                .build());
        Toast.makeText(MainActivity.this, "Event is recorded. Check Google Analytics!", Toast.LENGTH_LONG).show();
    }
});
6. Crashes and Exception Tracking
Exception Tracking is used to track Crashes and Exceptions. Any uncaught Exception can be sent to Google Analytics by using 2 methods.

1. Kövesse automatikusan az el nem fogott kivételeket a következő kód hozzáadásával az xml fájlban:

<bool name="ga_reportUncaughtExceptions">true</bool>

1. Ez egy speciális megvalósítás a nem elkapott kivételek nyomon követésére, ha nem használja az 1. módszert. A speciális konfiguráció megvalósításához használja a következő kódot:

• UncaughtExceptionHandler myHandler = new ExceptionReporter(
  myTracker, // Jelenleg használt Tracker.
  Thread.getDefaultUncaughtExceptionHandler(), // Jelenlegi alapértelmezett elfogatlan kivételkezelő.
  kontextus); // Az alkalmazás kontextusa.
• // Legyen a myHandler az új alapértelmezett elfogatlan kivételkezelő.
  Thread.setDefaultUncaughtExceptionHandler(myHandler);
  
  Az 1. módszer könnyebben konfigurálható, és előnyösebb.
• További konfiguráció:
• A Kivétel további leírásának megszerzéséhez és elküldéséhez a következő kódot használhatjuk:
• catch (IOException e) {
  // Tracker letöltése.
  Tracker t = ((AnalyticsSampleApp) getActivity().getApplication()).getTracker(
  TrackerName.APP_TRACKER);
• t.send(new HitBuilders.ExceptionBuilder()
  .setDescription(
  new StandardExceptionParser(this, null)
  .getDescription(Thread.currentThread().getName(), e))
  .setFatal(false)
  .build()
  );
• … // Figyelmeztetés megjelenítése a felhasználó számára, hogy jelenleg nem érhetők el a magas pontszámok.
  
  
  Ebben a Google Analytics Android-oktatóanyagban olyan helyzeteket teremtünk, amelyekben az alkalmazás kivételt és összeomlást generál. Lássuk őket egyenként.

a. Kivételkövetés

Here we will configure the Exception button so that an Exception will be created whenever user presses Exception Tracking button. Let us create an Array out of Bounds Exception by declaring the following code:
bException.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Exception e = null;
try{
                    int num[]={1,2,3,4};
                    System.out.println(num[5]);
                }catch (Exception f){
                    e = f;
                }
                if( e != null){
Toast.makeText(MainActivity.this, "The Exception is: " + e, Toast.LENGTH_LONG).show();
Tracker t = ((GoogleAnalyticsApplication) getApplication()).getDefaultTracker();
                    t.send(new HitBuilders.ExceptionBuilder()
                            .setDescription(new StandardExceptionParser(MainActivity.this, null).getDescription(Thread.currentThread().getName(), e))
                            .setFatal(false)
                            .build());
                }
}
        });
Here we used ExceptionBuilder() method from HitBuilders class to send the Exception to Google Analytics.
Note: Exceptions and Crashes usually take upto 24 hours to get registered in Google Analytics Dashboard. Google Analytics currently does not support Real time Crash and Exception tracking.
b. Crash Tracking:
We configure Crash Tracking Button so that when user presses the button, a toast message will be displayed and the app will crash after 1.5 seconds. Here we created crash by throwing null pointer exception
bCrashApp.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Toast.makeText(getApplicationContext(), "Get Ready for App Crash!", Toast.LENGTH_LONG).show();
                Runnable r = new Runnable() {
                    @Override
                    public void run() {
                        startCrash();
}
                    public void startCrash() {
                        //Manually throwing nullPointer Exception using throw keyword
                        throw null;
                    }
};
                Handler h = new Handler();
                h.postDelayed(r, 1500);
            }
        });

These are the most commonly used features of Google Analytics. Google offers a lot more features via Google Analytics. Refer to Documentation for integrating more features.
[widget id="text-4"]