Skip to content

Most visited

Recently visited

navigation
Geofencing / Application / src / com.example.android.wearable.geofencing /

MainActivity.java

1
/*
2
 * Copyright (C) 2014 The Android Open Source Project
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16
 
17
package com.example.android.wearable.geofencing;
18
 
19
import static com.example.android.wearable.geofencing.Constants.ANDROID_BUILDING_ID;
20
import static com.example.android.wearable.geofencing.Constants.ANDROID_BUILDING_LATITUDE;
21
import static com.example.android.wearable.geofencing.Constants.ANDROID_BUILDING_LONGITUDE;
22
import static com.example.android.wearable.geofencing.Constants.ANDROID_BUILDING_RADIUS_METERS;
23
import static com.example.android.wearable.geofencing.Constants.CONNECTION_FAILURE_RESOLUTION_REQUEST;
24
import static com.example.android.wearable.geofencing.Constants.GEOFENCE_EXPIRATION_TIME;
25
import static com.example.android.wearable.geofencing.Constants.TAG;
26
import static com.example.android.wearable.geofencing.Constants.YERBA_BUENA_ID;
27
import static com.example.android.wearable.geofencing.Constants.YERBA_BUENA_LATITUDE;
28
import static com.example.android.wearable.geofencing.Constants.YERBA_BUENA_LONGITUDE;
29
import static com.example.android.wearable.geofencing.Constants.YERBA_BUENA_RADIUS_METERS;
30
 
31
import android.app.Activity;
32
import android.app.PendingIntent;
33
import android.content.Intent;
34
import android.content.IntentSender;
35
import android.os.Bundle;
36
import android.util.Log;
37
import android.widget.Toast;
38
 
39
import com.google.android.gms.common.ConnectionResult;
40
import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks;
41
import com.google.android.gms.common.GooglePlayServicesUtil;
42
import com.google.android.gms.common.api.GoogleApiClient;
43
import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener;
44
import com.google.android.gms.location.Geofence;
45
import com.google.android.gms.location.LocationServices;
46
 
47
import java.util.ArrayList;
48
import java.util.List;
49
 
50
public class MainActivity extends Activity implements ConnectionCallbacks,
51
        OnConnectionFailedListener {
52
 
53
    // Internal List of Geofence objects. In a real app, these might be provided by an API based on
54
    // locations within the user's proximity.
55
    List<Geofence> mGeofenceList;
56
 
57
    // These will store hard-coded geofences in this sample app.
58
    private SimpleGeofence mAndroidBuildingGeofence;
59
    private SimpleGeofence mYerbaBuenaGeofence;
60
 
61
    // Persistent storage for geofences.
62
    private SimpleGeofenceStore mGeofenceStorage;
63
 
64
    private LocationServices mLocationService;
65
    // Stores the PendingIntent used to request geofence monitoring.
66
    private PendingIntent mGeofenceRequestIntent;
67
    private GoogleApiClient mApiClient;
68
 
69
    // Defines the allowable request types (in this example, we only add geofences).
70
    private enum REQUEST_TYPE {ADD}
71
    private REQUEST_TYPE mRequestType;
72
 
73
    @Override
74
    protected void onCreate(Bundle savedInstanceState) {
75
        super.onCreate(savedInstanceState);
76
        // Rather than displayng this activity, simply display a toast indicating that the geofence
77
        // service is being created. This should happen in less than a second.
78
        if (!isGooglePlayServicesAvailable()) {
79
            Log.e(TAG, "Google Play services unavailable.");
80
            finish();
81
            return;
82
        }
83
 
84
        mApiClient = new GoogleApiClient.Builder(this)
85
                .addApi(LocationServices.API)
86
                .addConnectionCallbacks(this)
87
                .addOnConnectionFailedListener(this)
88
                .build();
89
 
90
        mApiClient.connect();
91
 
92
        // Instantiate a new geofence storage area.
93
        mGeofenceStorage = new SimpleGeofenceStore(this);
94
        // Instantiate the current List of geofences.
95
        mGeofenceList = new ArrayList<Geofence>();
96
        createGeofences();
97
    }
98
 
99
    /**
100
     * In this sample, the geofences are predetermined and are hard-coded here. A real app might
101
     * dynamically create geofences based on the user's location.
102
     */
103
    public void createGeofences() {
104
        // Create internal "flattened" objects containing the geofence data.
105
        mAndroidBuildingGeofence = new SimpleGeofence(
106
                ANDROID_BUILDING_ID,                // geofenceId.
107
                ANDROID_BUILDING_LATITUDE,
108
                ANDROID_BUILDING_LONGITUDE,
109
                ANDROID_BUILDING_RADIUS_METERS,
110
                GEOFENCE_EXPIRATION_TIME,
111
                Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT
112
        );
113
        mYerbaBuenaGeofence = new SimpleGeofence(
114
                YERBA_BUENA_ID,                // geofenceId.
115
                YERBA_BUENA_LATITUDE,
116
                YERBA_BUENA_LONGITUDE,
117
                YERBA_BUENA_RADIUS_METERS,
118
                GEOFENCE_EXPIRATION_TIME,
119
                Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT
120
        );
121
 
122
        // Store these flat versions in SharedPreferences and add them to the geofence list.
123
        mGeofenceStorage.setGeofence(ANDROID_BUILDING_ID, mAndroidBuildingGeofence);
124
        mGeofenceStorage.setGeofence(YERBA_BUENA_ID, mYerbaBuenaGeofence);
125
        mGeofenceList.add(mAndroidBuildingGeofence.toGeofence());
126
        mGeofenceList.add(mYerbaBuenaGeofence.toGeofence());
127
    }
128
 
129
 
130
    @Override
131
    public void onConnectionFailed(ConnectionResult connectionResult) {
132
        // If the error has a resolution, start a Google Play services activity to resolve it.
133
        if (connectionResult.hasResolution()) {
134
            try {
135
                connectionResult.startResolutionForResult(this,
136
                        CONNECTION_FAILURE_RESOLUTION_REQUEST);
137
            } catch (IntentSender.SendIntentException e) {
138
                Log.e(TAG, "Exception while resolving connection error.", e);
139
            }
140
        } else {
141
            int errorCode = connectionResult.getErrorCode();
142
            Log.e(TAG, "Connection to Google Play services failed with error code " + errorCode);
143
        }
144
    }
145
 
146
    /**
147
     * Once the connection is available, send a request to add the Geofences.
148
     */
149
    @Override
150
    public void onConnected(Bundle connectionHint) {
151
        // Get the PendingIntent for the geofence monitoring request.
152
        // Send a request to add the current geofences.
153
        mGeofenceRequestIntent = getGeofenceTransitionPendingIntent();
154
        LocationServices.GeofencingApi.addGeofences(mApiClient, mGeofenceList,
155
                mGeofenceRequestIntent);
156
        Toast.makeText(this, getString(R.string.start_geofence_service), Toast.LENGTH_SHORT).show();
157
        finish();
158
    }
159
 
160
    @Override
161
    public void onConnectionSuspended(int i) {
162
        if (null != mGeofenceRequestIntent) {
163
            LocationServices.GeofencingApi.removeGeofences(mApiClient, mGeofenceRequestIntent);
164
        }
165
    }
166
 
167
 
168
    /**
169
     * Checks if Google Play services is available.
170
     * @return true if it is.
171
     */
172
    private boolean isGooglePlayServicesAvailable() {
173
        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
174
        if (ConnectionResult.SUCCESS == resultCode) {
175
            if (Log.isLoggable(TAG, Log.DEBUG)) {
176
                Log.d(TAG, "Google Play services is available.");
177
            }
178
            return true;
179
        } else {
180
            Log.e(TAG, "Google Play services is unavailable.");
181
            return false;
182
        }
183
    }
184
 
185
    /**
186
     * Create a PendingIntent that triggers GeofenceTransitionIntentService when a geofence
187
     * transition occurs.
188
     */
189
    private PendingIntent getGeofenceTransitionPendingIntent() {
190
        Intent intent = new Intent(this, GeofenceTransitionsIntentService.class);
191
        return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
192
    }
193
 
194
}
This site uses cookies to store your preferences for site-specific language and display options.

Hooray!