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
|
/*
* Copyright (C) 2014 Andrew Comminos
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package se.lublin.mumla.service;
import static android.app.PendingIntent.FLAG_CANCEL_CURRENT;
import static android.app.PendingIntent.FLAG_IMMUTABLE;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import androidx.core.app.NotificationCompat;
import se.lublin.mumla.R;
import se.lublin.mumla.app.DrawerAdapter;
import se.lublin.mumla.app.MumlaActivity;
/**
* Wrapper to create Mumla notifications.
* Created by andrew on 08/08/14.
*/
public class MumlaConnectionNotification {
private static final int NOTIFICATION_ID = 1;
private static final String BROADCAST_MUTE = "b_mute";
private static final String BROADCAST_DEAFEN = "b_deafen";
private static final String BROADCAST_OVERLAY = "b_overlay";
private Service mService;
private OnActionListener mListener;
private String mCustomTicker;
private String mCustomContentText;
private boolean mActionsShown;
private BroadcastReceiver mNotificationReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (BROADCAST_MUTE.equals(intent.getAction())) {
mListener.onMuteToggled();
} else if (BROADCAST_DEAFEN.equals(intent.getAction())) {
mListener.onDeafenToggled();
} else if (BROADCAST_OVERLAY.equals(intent.getAction())) {
mListener.onOverlayToggled();
}
}
};
/**
* Creates a foreground Mumla notification for the given service.
* @param service The service to register a foreground notification for.
* @param listener An listener for notification actions.
* @return A new MumlaNotification instance.
*/
public static MumlaConnectionNotification create(Service service, String ticker, String contentText,
OnActionListener listener) {
return new MumlaConnectionNotification(service, ticker, contentText, listener);
}
private MumlaConnectionNotification(Service service, String ticker, String contentText,
OnActionListener listener) {
mService = service;
mListener = listener;
mCustomTicker = ticker;
mCustomContentText = contentText;
mActionsShown = false;
}
public void setCustomTicker(String ticker) {
mCustomTicker = ticker;
}
public void setCustomContentText(String text) {
mCustomContentText = text;
}
public void setActionsShown(boolean actionsShown) {
mActionsShown = actionsShown;
}
/**
* Shows the notification and registers the notification action button receiver.
*/
public void show() {
createNotification();
IntentFilter filter = new IntentFilter();
filter.addAction(BROADCAST_DEAFEN);
filter.addAction(BROADCAST_MUTE);
filter.addAction(BROADCAST_OVERLAY);
try {
mService.registerReceiver(mNotificationReceiver, filter);
} catch (IllegalArgumentException e) {
// Thrown if receiver is already registered.
e.printStackTrace();
}
}
/**
* Hides the notification and unregisters the action receiver.
*/
public void hide() {
try {
mService.unregisterReceiver(mNotificationReceiver);
} catch (IllegalArgumentException e) {
// Thrown if receiver is not registered.
e.printStackTrace();
}
mService.stopForeground(true);
}
/**
* Called to update/create the service's foreground Mumla notification.
*/
private Notification createNotification() {
String channelId = "";
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
channelId = "connected_channel";
String channelName = mService.getString(R.string.connected);
NotificationChannel chan = new NotificationChannel(channelId, channelName,
NotificationManager.IMPORTANCE_DEFAULT);
NotificationManager manager = mService.getSystemService(NotificationManager.class);
manager.createNotificationChannel(chan);
}
NotificationCompat.Builder builder =
new NotificationCompat.Builder(mService, channelId);
// app name is always displayed in notification on >= O
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.M) {
builder.setContentTitle(mService.getString(R.string.app_name));
}
builder.setContentText(mCustomContentText);
builder.setSmallIcon(R.drawable.ic_stat_notify);
builder.setPriority(NotificationCompat.PRIORITY_DEFAULT);
builder.setCategory(NotificationCompat.CATEGORY_CALL);
builder.setShowWhen(false);
builder.setOngoing(true);
if (mActionsShown) {
// Add notification triggers
Intent muteIntent = new Intent(BROADCAST_MUTE);
Intent deafenIntent = new Intent(BROADCAST_DEAFEN);
Intent overlayIntent = new Intent(BROADCAST_OVERLAY);
builder.addAction(R.drawable.ic_action_microphone,
mService.getString(R.string.mute), PendingIntent.getBroadcast(mService, 1,
muteIntent, FLAG_CANCEL_CURRENT | FLAG_IMMUTABLE));
builder.addAction(R.drawable.ic_action_audio,
mService.getString(R.string.deafen), PendingIntent.getBroadcast(mService, 1,
deafenIntent, FLAG_CANCEL_CURRENT | FLAG_IMMUTABLE));
builder.addAction(R.drawable.ic_action_channels,
mService.getString(R.string.overlay), PendingIntent.getBroadcast(mService, 2,
overlayIntent, FLAG_CANCEL_CURRENT | FLAG_IMMUTABLE));
}
Intent channelListIntent = new Intent(mService, MumlaActivity.class);
channelListIntent.putExtra(MumlaActivity.EXTRA_DRAWER_FRAGMENT, DrawerAdapter.ITEM_SERVER);
// FLAG_CANCEL_CURRENT ensures that the extra always gets sent.
PendingIntent pendingIntent = PendingIntent.getActivity(mService, 0,
channelListIntent, FLAG_CANCEL_CURRENT | FLAG_IMMUTABLE);
builder.setContentIntent(pendingIntent);
Notification notification = builder.build();
mService.startForeground(NOTIFICATION_ID, notification);
return notification;
}
public interface OnActionListener {
void onMuteToggled();
void onDeafenToggled();
void onOverlayToggled();
}
}
|
