1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.wearable.synchronizednotifications;
import android.app.PendingIntent;
import android.content.Intent;
import android.support.v4.app.Fragment;
import android.app.Activity;
import android.net.Uri;
import android.os.Bundle;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationManagerCompat;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;
import com.example.android.wearable.synchronizednotifications.common.Constants;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.wearable.DataApi;
import com.google.android.gms.wearable.PutDataMapRequest;
import com.google.android.gms.wearable.PutDataRequest;
import com.google.android.gms.wearable.Wearable;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* A simple fragment that presents three buttons that would trigger three different combinations of
* notifications on the handset and the watch:
* <ul>
* <li>The first button builds a simple local-only notification on the handset.</li>
* <li>The second one creates a wearable-only notification by putting a data item in the shared data
* store and having a {@link com.google.android.gms.wearable.WearableListenerService} listen for
* that on the wearable</li>
* <li>The third one creates a local notification and a wearable notification by combining the above
* two. It, however, demonstrates how one can set things up so that the dismissal of one
* notification results in the dismissal of the other one.</li>
* </ul>
*/
public class SynchronizedNotificationsFragment extends Fragment
implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
private static final String TAG = "SynchronizedNotificationsFragment";
private GoogleApiClient mGoogleApiClient;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mGoogleApiClient = new GoogleApiClient.Builder(this.getActivity())
.addApi(Wearable.API)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();
setHasOptionsMenu(true);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.btn_phone_only:
buildLocalOnlyNotification(getString(R.string.phone_only), now(),
Constants.PHONE_ONLY_ID, false);
return true;
case R.id.btn_wear_only:
buildWearableOnlyNotification(getString(R.string.wear_only), now(),
Constants.WATCH_ONLY_PATH);
return true;
case R.id.btn_different:
buildMirroredNotifications(getString(R.string.phone_both), getString(R.string.watch_both), now());
return true;
}
return false;
}
/**
* Builds a local-only notification for the handset. This is achieved by using
* <code>setLocalOnly(true)</code>. If <code>withDismissal</code> is set to <code>true</code>, a
* {@link android.app.PendingIntent} will be added to handle the dismissal of notification to
* be able to remove the mirrored notification on the wearable.
*/
private void buildLocalOnlyNotification(String title, String content, int notificationId,
boolean withDismissal) {
NotificationCompat.Builder builder = new NotificationCompat.Builder(this.getActivity());
builder.setContentTitle(title)
.setContentText(content)
.setLocalOnly(true)
.setSmallIcon(R.drawable.ic_launcher);
if (withDismissal) {
Intent dismissIntent = new Intent(Constants.ACTION_DISMISS);
dismissIntent.putExtra(Constants.KEY_NOTIFICATION_ID, Constants.BOTH_ID);
PendingIntent pendingIntent = PendingIntent
.getService(this.getActivity(), 0, dismissIntent, PendingIntent.FLAG_UPDATE_CURRENT);
builder.setDeleteIntent(pendingIntent);
}
NotificationManagerCompat.from(this.getActivity()).notify(notificationId, builder.build());
}
/**
* Builds a DataItem that on the wearable will be interpreted as a request to show a
* notification. The result will be a notification that only shows up on the wearable.
*/
private void buildWearableOnlyNotification(String title, String content, String path) {
if (mGoogleApiClient.isConnected()) {
PutDataMapRequest putDataMapRequest = PutDataMapRequest.create(path);
putDataMapRequest.getDataMap().putString(Constants.KEY_CONTENT, content);
putDataMapRequest.getDataMap().putString(Constants.KEY_TITLE, title);
PutDataRequest request = putDataMapRequest.asPutDataRequest();
Wearable.DataApi.putDataItem(mGoogleApiClient, request)
.setResultCallback(new ResultCallback<DataApi.DataItemResult>() {
@Override
public void onResult(DataApi.DataItemResult dataItemResult) {
if (!dataItemResult.getStatus().isSuccess()) {
Log.e(TAG, "buildWatchOnlyNotification(): Failed to set the data, "
+ "status: " + dataItemResult.getStatus().getStatusCode());
}
}
});
} else {
Log.e(TAG, "buildWearableOnlyNotification(): no Google API Client connection");
}
}
/**
* Builds a local notification and sets a DataItem that will be interpreted by the wearable as
* a request to build a notification on the wearable as as well. The two notifications show
* different messages.
* Dismissing either of the notifications will result in dismissal of the other; this is
* achieved by creating a {@link android.app.PendingIntent} that results in removal of
* the DataItem that created the watch notification. The deletion of the DataItem is observed on
* both sides, using WearableListenerService callbacks, and is interpreted on each side as a
* request to dismiss the corresponding notification.
*/
private void buildMirroredNotifications(String phoneTitle, String watchTitle, String content) {
if (mGoogleApiClient.isConnected()) {
// Wearable notification
buildWearableOnlyNotification(watchTitle, content, Constants.BOTH_PATH);
// Local notification, with a pending intent for dismissal
buildLocalOnlyNotification(phoneTitle, content, Constants.BOTH_ID, true);
}
}
@Override
public void onStart() {
super.onStart();
mGoogleApiClient.connect();
}
@Override
public void onStop() {
mGoogleApiClient.disconnect();
super.onStop();
}
@Override
public void onConnected(Bundle bundle) {
}
@Override
public void onConnectionSuspended(int i) {
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.e(TAG, "Failed to connect to Google API Client");
}
/**
* Returns a string built from the current time
*/
private String now() {
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
return sdf.format(new Date());
}
}
|
