c2c/c2c-push
c2c/c2c-push
2
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Repo created

Browse source
This commit is contained in:
Fr4nz D13trich 2025-11-22 13:50:23 +01:00
parent c7f60b13d1
commit e465363d01
120 changed files with 5776 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

83
app/src/main/java/com/polar/nextcloudservices/API/INextcloudAbstractAPI.java Normal file
View file

@ -0,0 +1,83 @@
package com.polar.nextcloudservices.API;
import android.graphics.Bitmap;
import com.polar.nextcloudservices.API.websocket.NotificationWebsocket;
import com.polar.nextcloudservices.API.websocket.INotificationWebsocketEventListener;
import com.polar.nextcloudservices.Services.INotificationListener;
import com.polar.nextcloudservices.Services.Status.StatusCheckable;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
/*
* Nextcloud abstract API creates possibility to use different libraries for
* polling for notifications. This is needed to use Nextcloud SSO library
* since it does not give per-app key.
* The inheritors of this interface should be passed to NotificationService.
*/
public interface INextcloudAbstractAPI extends StatusCheckable {
/**
* Gets all notifications from server
* @param service PollUpdateListener which handles notifications
* @return notifications response as a JSONObject
*/
JSONObject getNotifications(INotificationListener service);
/**
* Removes notification from server
* @param id id of notification to remove
*/
void removeNotification(int id);
/**
* Sends reply to talk chatroom
* @param chatroom id of a chat
* @param message message to send
* @throws IOException in case of network error
* @throws JSONException in case of low-level errors(like allocation failure),
* should be almost impossible to get it here as JSON should be used for serialization only
*/
void sendTalkReply(String chatroom, String message) throws IOException, JSONException;
/**
* Get user avatar
* @param userId username to get avatar of
* @return avatar bitmap
* @throws Exception in case of any errors
*/
Bitmap getUserAvatar(String userId) throws Exception;
/**
* Gets image preview from server
* @param path path to image
* @return bitmap received from server
* @throws Exception in case of any errors
*/
Bitmap getImagePreview(String path) throws Exception;
/**
* Executes action which is inside of notifications
* @param link Link to action
* @param method method which should be used for querying link
* @throws Exception in case of any errors
*/
void sendAction(String link, String method) throws Exception;
/**
* @doc Checks new notifications without querying all of them directly
* @return true if there is new notifications on server
* @throws Exception in case of any error
*/
boolean checkNewNotifications() throws Exception;
/**
* @return WebsocketClient instance which holds pre-authorized connection
* @throws Exception in case of any unhandlable error
* @doc Gets websocket client which is authorized and receives notification updates
*/
NotificationWebsocket getNotificationsWebsocket(INotificationWebsocketEventListener listener) throws Exception;
}

294
app/src/main/java/com/polar/nextcloudservices/API/NextcloudHttpAPI.java Normal file
View file

@ -0,0 +1,294 @@
package com.polar.nextcloudservices.API;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Base64;
import android.util.Log;
import androidx.annotation.NonNull;
import com.polar.nextcloudservices.API.websocket.NotificationWebsocket;
import com.polar.nextcloudservices.API.websocket.INotificationWebsocketEventListener;
import com.polar.nextcloudservices.BuildConfig;
import com.polar.nextcloudservices.Services.INotificationListener;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import com.polar.nextcloudservices.Services.Status.Status;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
import javax.net.ssl.HttpsURLConnection;
public class NextcloudHttpAPI implements INextcloudAbstractAPI {
private final String TAG = "NextcloudHttpAPI";
private final String UA = "NextcloudServices/" + BuildConfig.VERSION_NAME;
private String mStatusString = "Updating settings";
private boolean lastPollSuccessful = false;
private final ServiceSettings mServiceSettings;
private String mETag = "";
public NextcloudHttpAPI(ServiceSettings settings){
mServiceSettings = settings;
}
private static String getAuth(String user, String password) {
//Log.d("NotificationService.PollTask",user+":"+password);
return Base64.encodeToString((user + ":" + password).getBytes(StandardCharsets.UTF_8), Base64.DEFAULT);
}
private HttpURLConnection request(String path, String method,
Boolean setAccept) throws IOException {
String user = mServiceSettings.getUsername();
String password = mServiceSettings.getPassword();
String baseUrl = mServiceSettings.getServer();
String prefix = "https://";
if (mServiceSettings.getUseHttp()) {
prefix = "http://";
}
String endpoint = prefix + baseUrl + path;
//Log.d(TAG, endpoint);
URL url = new URL(endpoint);
HttpURLConnection conn;
if (mServiceSettings.getUseHttp()) {
conn = (HttpURLConnection) url.openConnection();
} else {
conn = (HttpsURLConnection) url.openConnection();
}
conn.setRequestProperty("Authorization", "Basic " + getAuth(user, password));
conn.setRequestProperty("Host", url.getHost());
conn.setRequestProperty("User-agent", UA);
conn.setRequestProperty("OCS-APIRequest", "true");
if (setAccept) {
conn.setRequestProperty("Accept", "application/json");
}
conn.setRequestMethod(method);
conn.setReadTimeout(60000);
conn.setConnectTimeout(5000);
return conn;
}
@Override
public void removeNotification(int id) {
Log.d(TAG, "Removing notification " + id);
try {
String prefix = "https://";
if (mServiceSettings.getUseHttp()) {
prefix = "http://";
}
HttpURLConnection conn =
request("/ocs/v2.php/apps/notifications/api/v2/notifications/" + id,
"DELETE", false);
String responseCode = Integer.toString(conn.getResponseCode());
Log.d(TAG, "--> DELETE " + prefix + mServiceSettings.getServer()
+ "/ocs/v2.php/apps/notifications/api/v2/notifications/" +
id + " -- " + responseCode);
} catch (IOException e) {
Log.e(TAG, "Failed to DELETE notification: " + e.getLocalizedMessage());
Log.d(TAG, "Exception was: " + e);
}
}
private static String getEndpoint(@NonNull ServiceSettings settings){
String baseUrl = settings.getServer();
String prefix = "https://";
if (settings.getUseHttp()) {
prefix = "http://";
}
return prefix + baseUrl;
}
private HttpURLConnection getBaseConnection(URL url, String method)
throws IOException {
HttpURLConnection conn;
if (mServiceSettings.getUseHttp()) {
conn = (HttpURLConnection) url.openConnection();
} else {
conn = (HttpsURLConnection) url.openConnection();
}
conn.setRequestProperty("Authorization", "Basic " + getAuth(mServiceSettings.getUsername(),
mServiceSettings.getPassword()));
conn.setRequestProperty("Host", url.getHost());
conn.setRequestProperty("User-agent", UA);
conn.setRequestProperty("OCS-APIRequest", "true");
conn.setRequestProperty("Accept", "application/json");
conn.setRequestProperty("Content-Type", "application/json");
conn.setRequestMethod(method);
return conn;
}
@Override
public void sendTalkReply(String chatroom, String message) throws IOException {
String endpoint = getEndpoint(mServiceSettings) + "/ocs/v2.php/apps/spreed/api/v1/chat/" + chatroom;
URL url = new URL(endpoint);
HttpURLConnection conn = getBaseConnection(url, "POST");
conn.setDoOutput(true);
conn.setConnectTimeout(5000);
//FIXME: create separate params generator
final String params = "{\"message\": \"" + message + "\", \"chatroom\": \"" + chatroom + "\"}";
OutputStream os = conn.getOutputStream();
os.write(params.getBytes(StandardCharsets.UTF_8));
os.flush();
os.close();
int code = conn.getResponseCode();
Log.d(TAG, "--> POST " + endpoint + " -- " + code);
}
public Bitmap getUserAvatar(String userId) throws IOException {
HttpURLConnection connection = request("/index.php/avatar/"+userId+"/256",
"GET", false);
connection.setDoInput(true);
return BitmapFactory.decodeStream(connection.getInputStream());
}
@Override
public Bitmap getImagePreview(String imageId) throws Exception {
HttpURLConnection connection = request( "/index.php/core/preview?fileId="
+ imageId + "&x=100&y=100&a=1",
"GET", false);
connection.setRequestProperty("Accept", "image/*");
connection.setDoInput(true);
int responseCode = connection.getResponseCode();
Log.d(TAG, "--> GET " + getEndpoint(mServiceSettings)
+ "/index.php/core/preview?fileId="+imageId+"&x=100&y=100&a=1 -- " + responseCode);
return BitmapFactory.decodeStream(connection.getInputStream());
}
@Override
public void sendAction(String link,
String method) throws Exception {
String endpoint = getEndpoint(mServiceSettings) + link;
URL url = new URL(endpoint);
HttpURLConnection connection = getBaseConnection(url, method);
connection.setConnectTimeout(5000);
connection.setDoInput(true);
int responseCode = connection.getResponseCode();
Log.d(TAG, "--> " + method + getEndpoint(mServiceSettings)
+ link + "--" + responseCode);
}
@Override
public boolean checkNewNotifications() throws Exception {
HttpURLConnection connection = request(
"/ocs/v2.php/apps/notifications/api/v2/notifications",
"HEAD", false);
connection.setConnectTimeout(5000);
connection.setDoInput(true);
String lastETag = connection.getHeaderField("ETag");
if(!Objects.equals(lastETag, mETag)){
Log.d(TAG, "Detected new notifications");
mETag = lastETag;
return true;
}
return false;
}
@NonNull
private JSONObject readConnectionToJson(@NonNull HttpURLConnection conn)
throws IOException, JSONException{
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder buffer = new StringBuilder();
String line;
while ((line = in.readLine()) != null) {
buffer.append(line);
}
in.close();
return new JSONObject(buffer.toString());
}
//See get_endpoint from
// https://github.com/nextcloud/notify_push/blob/main/test_client/src/main.rs
@NonNull
private String getWebsocketURL() throws Exception {
HttpURLConnection connection = request(
"/ocs/v2.php/cloud/capabilities",
"GET", true);
connection.setConnectTimeout(5000);
connection.setDoInput(true);
JSONObject capabilities = readConnectionToJson(connection);
return capabilities.getJSONObject("ocs")
.getJSONObject("data")
.getJSONObject("capabilities")
.getJSONObject("notify_push")
.getJSONObject("endpoints")
.getString("websocket");
}
@Override
public NotificationWebsocket getNotificationsWebsocket(INotificationWebsocketEventListener listener) throws Exception {
Log.i(TAG, "Starting new websocket connection");
String endpoint = "";
try {
endpoint = getWebsocketURL();
} catch (Exception e){
Log.e(TAG, "Can not get websocket URL", e);
return null;
}
NotificationWebsocket client = new NotificationWebsocket(new URI(endpoint),
mServiceSettings.getUsername(),
mServiceSettings.getPassword(),
listener, this);
client.connect();
return client;
}
@Override
public JSONObject getNotifications(INotificationListener service) {
try {
HttpURLConnection conn = request("/ocs/v2.php/apps/notifications/api/v2/notifications",
"GET", true);
conn.setDoInput(true);
String responseCode = Integer.toString(conn.getResponseCode());
Log.d(TAG, "--> GET "+ getEndpoint(mServiceSettings) + "/ocs/v2.php/apps/notifications/api/v2/notifications -- " + responseCode);
//Log.d(TAG, buffer.toString());
JSONObject response = readConnectionToJson(conn);
lastPollSuccessful = true;
service.onNewNotifications(response);
return response;
} catch (JSONException e) {
Log.e(TAG, "Error parsing JSON");
e.printStackTrace();
mStatusString = "Disconnected: server has sent bad response: " + e.getLocalizedMessage();
return null;
} catch (java.io.FileNotFoundException e) {
e.printStackTrace();
mStatusString = "Disconnected: File not found: check your credentials and Nextcloud instance.";
return null;
} catch (IOException e) {
Log.e(TAG, "Error while getting response");
e.printStackTrace();
mStatusString = "Disconnected: I/O error: " + e.getLocalizedMessage();
return null;
} catch (Exception e) {
e.printStackTrace();
mStatusString = "Disconnected: " + e.getLocalizedMessage();
return null;
}
}
@Override
public Status getStatus(Context context) {
if(lastPollSuccessful){
return Status.Ok();
}
return Status.Failed(mStatusString);
}
}

197
app/src/main/java/com/polar/nextcloudservices/API/NextcloudSSOAPI.java Normal file
View file

@ -0,0 +1,197 @@
package com.polar.nextcloudservices.API;
/*
* Implements API for accounts imported from nextcloud.
*/
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.util.Log;
import com.google.gson.GsonBuilder;
import com.nextcloud.android.sso.QueryParam;
import com.nextcloud.android.sso.aidl.NextcloudRequest;
import com.nextcloud.android.sso.api.NextcloudAPI;
import com.nextcloud.android.sso.model.SingleSignOnAccount;
import com.polar.nextcloudservices.API.websocket.NotificationWebsocket;
import com.polar.nextcloudservices.API.websocket.INotificationWebsocketEventListener;
import com.polar.nextcloudservices.Services.INotificationListener;
import com.polar.nextcloudservices.Services.Status.Status;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import kotlin.NotImplementedError;
public class NextcloudSSOAPI implements INextcloudAbstractAPI {
final private NextcloudAPI API;
final private static String TAG = "NextcloudSSOAPI";
private boolean lastPollSuccessful = false;
private String mStatusString = "Updating settings";
private String mETag = "";
public NextcloudSSOAPI(Context context, SingleSignOnAccount ssoAccount) {
NextcloudAPI.ApiConnectedListener apiCallback = new NextcloudAPI.ApiConnectedListener() {
@Override
public void onConnected() {
/*stub*/
}
@Override
public void onError(Exception ex) {
Log.e(TAG, "Exception in Nextcloud API");
ex.printStackTrace();
}
};
API = new NextcloudAPI(context, ssoAccount, new GsonBuilder().create(), apiCallback);
}
@Override
public JSONObject getNotifications(INotificationListener service) {
Log.d(TAG, "getNotifications");
Map<String, List<String>> header = new HashMap<>();
LinkedList<String> values = new LinkedList<>();
values.add("application/json");
header.put("Accept", values);
NextcloudRequest request = new NextcloudRequest.Builder().setMethod("GET")
.setUrl(Uri.encode("/ocs/v2.php/apps/notifications/api/v2/notifications", "/"))
.setHeader(header)
.build();
StringBuilder buffer = new StringBuilder();
try {
BufferedReader in = new BufferedReader(
new InputStreamReader(API.performNetworkRequestV2(request).getBody()));
String line;
while ((line = in.readLine()) != null) {
buffer.append(line);
}
in.close();
} catch (Exception e) {
mStatusString = "Disconnected: " + e.getLocalizedMessage();
lastPollSuccessful = false;
e.printStackTrace();
return null;
}
try {
JSONObject response = new JSONObject(buffer.toString());
service.onNewNotifications(response);
Log.d(TAG, "Setting lastPollSuccessful as true");
lastPollSuccessful = true;
return response;
} catch (JSONException e) {
Log.e(TAG, "Error parsing JSON");
e.printStackTrace();
mStatusString = "Disconnected: server has sent bad response: " + e.getLocalizedMessage();
return null;
}
}
@Override
public void removeNotification(int id) {
Map<String, List<String>> header = new HashMap<>();
LinkedList<String> values = new LinkedList<>();
values.add("application/json");
header.put("Accept", values);
NextcloudRequest request = new NextcloudRequest.Builder().setMethod("DELETE")
.setUrl(Uri.encode("/ocs/v2.php/apps/notifications/api/v2/notifications/"+id, "/"))
.setHeader(header)
.build();
try {
API.performNetworkRequest(request);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void sendTalkReply(String chatroom, String message) throws JSONException {
Map<String, List<String>> header = new HashMap<>();
LinkedList<String> values = new LinkedList<>();
values.add("application/json");
header.put("Accept", values);
header.put("Content-Type", values);
JSONObject jsonParams = new JSONObject();
jsonParams.put("message", message);
jsonParams.put("chatroom", chatroom);
final String params = jsonParams.toString();
Log.d(TAG, "POST to /ocs/v2.php/apps/spreed/api/v1/chat/" + chatroom);
NextcloudRequest request = new NextcloudRequest.Builder().setMethod("POST")
.setUrl(Uri.encode("/ocs/v2.php/apps/spreed/api/v1/chat/" + chatroom, "/"))
.setHeader(header)
.setRequestBody(params)
.build();
try {
API.performNetworkRequestV2(request);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Bitmap getUserAvatar(String userId) throws Exception {
NextcloudRequest request = new NextcloudRequest.Builder().setMethod("GET")
.setUrl(Uri.encode("/index.php/avatar/"+userId+"/256 ", "/"))
.build();
InputStream stream = API.performNetworkRequest(request);
return BitmapFactory.decodeStream(stream);
}
@Override
public Bitmap getImagePreview(String imageId) throws Exception {
Collection<QueryParam> parameter = new LinkedList<>();
parameter.add(new QueryParam("fileId", imageId));
parameter.add(new QueryParam("x", "100"));
parameter.add(new QueryParam("y", "100"));
parameter.add(new QueryParam("a", "1"));
NextcloudRequest request = new NextcloudRequest.Builder().setMethod("GET")
.setUrl(Uri.encode("/index.php/core/preview", "/"))
.setParameter(parameter)
.build();
InputStream stream = API.performNetworkRequest(request);
return BitmapFactory.decodeStream(stream);
}
@Override
public void sendAction(String link, String method) throws Exception {
NextcloudRequest request = new NextcloudRequest.Builder().setMethod(method)
.setUrl(Uri.encode(link, "/")).build();
API.performNetworkRequest(request);
}
@Override
public boolean checkNewNotifications() throws Exception {
return true;
}
@Override
public NotificationWebsocket getNotificationsWebsocket(INotificationWebsocketEventListener listener) throws Exception {
throw new NotImplementedError("getNotificationsWebsoket() is not implemented for SSO API");
}
@Override
public Status getStatus(Context context) {
if(lastPollSuccessful){
Log.d(TAG, "Last poll is successful");
return Status.Ok();
}
return Status.Failed(mStatusString);
}
}

16
app/src/main/java/com/polar/nextcloudservices/API/websocket/INotificationWebsocketEventListener.java Normal file
View file

@ -0,0 +1,16 @@
package com.polar.nextcloudservices.API.websocket;
import com.polar.nextcloudservices.Services.INotificationListener;
public interface INotificationWebsocketEventListener extends INotificationListener {
/**
* Called whenever websocket is disconnected
* @param isError whether disconnect resulted from error
*/
void onWebsocketDisconnected(boolean isError);
/**
* Called whenever websocket connection is established
*/
void onWebsocketConnected();
}

116
app/src/main/java/com/polar/nextcloudservices/API/websocket/NotificationWebsocket.java Normal file
View file

@ -0,0 +1,116 @@
package com.polar.nextcloudservices.API.websocket;
import android.content.Context;
import android.util.Log;
import com.polar.nextcloudservices.API.INextcloudAbstractAPI;
import com.polar.nextcloudservices.Services.Status.Status;
import com.polar.nextcloudservices.Services.Status.StatusCheckable;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;
class NotificationWebsocketConfig{
public final static String NOTIFICATION_MESSAGE = "notify_notification";
public final static String LISTEN_TOPIC ="listen notify_file_id";
}
public class NotificationWebsocket extends WebSocketClient implements StatusCheckable {
private final static String TAG = "NotificationWebsocket";
private final String mUsername;
private final String mPassword;
private final INotificationWebsocketEventListener mNotificationListener;
private String mStatus;
private final INextcloudAbstractAPI mAPI;
private boolean isConnected;
public NotificationWebsocket(URI serverUri, String username, String password,
INotificationWebsocketEventListener notificationListener,
INextcloudAbstractAPI api) {
super(serverUri);
mUsername = username;
mPassword = password;
mNotificationListener = notificationListener;
isConnected = false;
mStatus = "Disconnected";
mAPI = api;
}
/**
* @param handshakedata The handshake of the websocket instance
*/
@Override
public void onOpen(ServerHandshake handshakedata) {
Log.i(TAG, "Connected to websocket");
send(mUsername);
send(mPassword);
send(NotificationWebsocketConfig.LISTEN_TOPIC);
isConnected = true;
mStatus = "Connected";
mNotificationListener.onWebsocketConnected();
}
/**
* @param message The UTF-8 decoded message that was received.
*/
@Override
public void onMessage(String message) {
Log.d(TAG, "Got message: " + message);
if(message.equals(NotificationWebsocketConfig.NOTIFICATION_MESSAGE)) {
mAPI.getNotifications(mNotificationListener);
}
}
/**
* @param code The codes can be looked up here: {@link CloseFrame}
* @param reason Additional information string
* @param remote Returns whether or not the closing of the connection was initiated by the remote
* host.
*/
@Override
public void onClose(int code, String reason, boolean remote) {
if(remote){
Log.w(TAG, "Remote has disconnected, code=" + code + ", reason=" + reason);
mStatus = "Remote disconnected";
} else {
Log.i(TAG, "We have disconnected, code=" + code + ", reason=" + reason);
mStatus = "Disconnected";
}
isConnected = false;
mNotificationListener.onWebsocketDisconnected(false);
}
/**
* @param ex The exception causing this error
*/
@Override
public void onError(Exception ex) {
Log.e(TAG, "Error in websocket", ex);
isConnected = false;
mStatus = "Unexpected error in websocket connection";
mNotificationListener.onWebsocketDisconnected(true);
}
/**
* @param context context which may be used for obtaining app and device status
* @return status information in form of Status class
*/
@Override
public Status getStatus(Context context) {
if(isConnected){
return Status.Ok();
}else{
return Status.Failed(mStatus);
}
}
/**
* Checks that websocket is connected
* @return true if websocket is connected
*/
public boolean getConnected(){
return isConnected;
}
}

51
app/src/main/java/com/polar/nextcloudservices/Adapters/CreditsAdapter.java Normal file
View file

@ -0,0 +1,51 @@
package com.polar.nextcloudservices.Adapters;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.bumptech.glide.Glide;
import com.bumptech.glide.annotation.GlideModule;
import com.polar.nextcloudservices.R;
import com.polar.nextcloudservices.ContributorDetails;
import java.util.List;
public class CreditsAdapter extends ArrayAdapter<ContributorDetails> {
Context context;
List<ContributorDetails> details;
public CreditsAdapter(@NonNull Context context, int resource, @NonNull List<ContributorDetails> objects) {
super(context, resource, objects);
this.context = context;
this.details = objects;
}
@Nullable
@Override
public ContributorDetails getItem(int position) {
return details.get(position);
}
@NonNull
@Override
public View getView(int position, @Nullable View convertView, @NonNull ViewGroup parent) {
convertView = LayoutInflater.from(context).inflate(R.layout.credits_contributer, parent, false);
ImageView UserImage = convertView.findViewById(R.id.userImage);
TextView userName = convertView.findViewById(R.id.userName);
TextView contribution = convertView.findViewById(R.id.contribution);
TextView githubName = convertView.findViewById(R.id.github_name);
userName.setText(details.get(position).Name);
contribution.setText(details.get(position).contribution);
githubName.setText(details.get(position).github_name);
Glide.with(context).load(details.get(position).imageUrl).placeholder(R.drawable.user).circleCrop().into(UserImage);
return convertView;
}
}

29
app/src/main/java/com/polar/nextcloudservices/BootReceiver.java Normal file
View file

@ -0,0 +1,29 @@
package com.polar.nextcloudservices;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import android.os.Build;
import com.polar.nextcloudservices.Services.NotificationPollService;
import com.polar.nextcloudservices.Services.NotificationServiceController;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
public class BootReceiver extends BroadcastReceiver {
private void startService(Context context){
NotificationServiceController controller =
new NotificationServiceController(new ServiceSettings(context));
controller.startService(context);
}
@Override
public void onReceive(Context context, Intent intent) {
if (Intent.ACTION_BOOT_COMPLETED.equals(intent.getAction())) {
startService(context);
Log.i("BootReceiver", "received boot completed");
}
}
}

5
app/src/main/java/com/polar/nextcloudservices/Config.java Normal file
View file

@ -0,0 +1,5 @@
package com.polar.nextcloudservices;
public class Config {
public static final String NotificationEventAction = "com.polar.nextcloudservices.Notifications.NOTIFICATION_EVENT";
}

16
app/src/main/java/com/polar/nextcloudservices/ContributorDetails.java Normal file
View file

@ -0,0 +1,16 @@
package com.polar.nextcloudservices;
public class ContributorDetails {
public String Name;
public String contribution;
public String imageUrl;
public String github_name;
public ContributorDetails(String name, String contribution, String imageUrl, String github_name) {
this.Name = name;
this.contribution = contribution;
this.imageUrl = imageUrl;
this.github_name = github_name;
}
}

71
app/src/main/java/com/polar/nextcloudservices/CreditsActivity.java Normal file
View file

@ -0,0 +1,71 @@
package com.polar.nextcloudservices;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ListView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.browser.customtabs.CustomTabsIntent;
import com.polar.nextcloudservices.Adapters.CreditsAdapter;
import java.util.ArrayList;
import java.util.List;
public class CreditsActivity extends AppCompatActivity {
private final String TAG = "CreditsActivity";
List<ContributorDetails> details = new ArrayList<>();
String[] licenses;
String[] urls;
String[] owner_Name;
String[] owner_github_Name;
String[] owner_github_image;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setTitle("Credits");
setContentView(R.layout.activity_credits);
licenses = getResources().getStringArray(R.array.oss_libs);
urls = getResources().getStringArray(R.array.oss_libs_links);
owner_Name = getResources().getStringArray(R.array.oss_libs_owner_name);
owner_github_Name = getResources().getStringArray(R.array.oss_libs_owner_github_name);
owner_github_image = getResources().getStringArray(R.array.oss_libs_owner_Img);
details_add();
ListView mListView = (ListView) findViewById(R.id.oss_licenses_list);
if (mListView == null) {
Log.wtf(TAG, "ListView is null!");
throw new RuntimeException("ListView should not be null!");
}
CreditsAdapter aAdapter = new CreditsAdapter(this, R.layout.credits_contributer, details);
mListView.setAdapter(aAdapter);
mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
CustomTabsIntent browserIntent = new CustomTabsIntent.Builder()
.setUrlBarHidingEnabled(true)
.setShowTitle(false)
.setStartAnimations(parent.getContext(), android.R.anim.fade_in, android.R.anim.fade_out)
.setExitAnimations(parent.getContext(), android.R.anim.fade_in, android.R.anim.fade_out)
.setColorScheme(CustomTabsIntent.COLOR_SCHEME_SYSTEM)
.setShareState(CustomTabsIntent.SHARE_STATE_OFF)
.build();
browserIntent.launchUrl(parent.getContext(), Uri.parse(urls[position]));
}
});
}
// A function to add the contributor details in details(Arraylist) which is to be shown in credits activity
public void details_add() {
for (int i = 0; i < owner_Name.length; ++i) {
details.add(new ContributorDetails(owner_Name[i], licenses[i], owner_github_image[i], owner_github_Name[i]));
}
}
}

8
app/src/main/java/com/polar/nextcloudservices/NSGlideModule.java Normal file
View file

@ -0,0 +1,8 @@
package com.polar.nextcloudservices;
import com.bumptech.glide.annotation.GlideModule;
import com.bumptech.glide.module.AppGlideModule;
//This is to silence Glides' warning about absence of GlideModule
@GlideModule
public final class NSGlideModule extends AppGlideModule {}

39
app/src/main/java/com/polar/nextcloudservices/Notification/AbstractNotificationProcessor.java Normal file
View file

@ -0,0 +1,39 @@
package com.polar.nextcloudservices.Notification;
import android.app.NotificationManager;
import android.content.Context;
import android.content.Intent;
import androidx.core.app.NotificationCompat;
import org.json.JSONObject;
public interface AbstractNotificationProcessor {
/**
* @param id Notification ID in Nextcloud
* @param builderResult a notification builder result which should be updated
* @param manager An Android notification manager service
* @param rawNotification JSON representation of notification
* @param context Android Context object for interacting with Android
* @param controller object which is used for coordinating all notification activity
* @return a result of builder
* @throws Exception throws any exception which occured in notification processors
*/
NotificationBuilderResult updateNotification(int id, NotificationBuilderResult builderResult,
NotificationManager manager,
JSONObject rawNotification,
Context context, NotificationController controller) throws Exception;
/**
* @param event event that occured
* @param intent intent triggered by event
* @param controller object which is used for coordinating all notification activity
*/
void onNotificationEvent(NotificationEvent event, Intent intent,
NotificationController controller);
/**
* @return Priority of notification processor
*/
int getPriority();
}

20
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationBroadcastReceiver.java Normal file
View file

@ -0,0 +1,20 @@
package com.polar.nextcloudservices.Notification;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
public class NotificationBroadcastReceiver extends BroadcastReceiver {
private final NotificationEventReceiver mNotificationEventReceiver;
private static final String TAG = "Notification.NotificationBroadcastReceiver";
public NotificationBroadcastReceiver(NotificationEventReceiver notificationEventReceiver){
mNotificationEventReceiver = notificationEventReceiver;
}
@Override
public void onReceive(Context context, Intent intent) {
Log.d(TAG, "Received notification event");
NotificationEvent event_type = (NotificationEvent) intent.getSerializableExtra("notification_event");
mNotificationEventReceiver.onNotificationEvent(event_type, intent);
}
}

54
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationBuilder.java Normal file
View file

@ -0,0 +1,54 @@
package com.polar.nextcloudservices.Notification;
import android.app.NotificationManager;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import androidx.core.app.NotificationCompat;
import org.json.JSONObject;
import java.util.Vector;
public class NotificationBuilder {
private final Vector<AbstractNotificationProcessor> processors;
private final static String TAG = "Notification.NotificationBuilder";
public NotificationBuilder(){
processors = new Vector<>();
}
public NotificationBuilderResult buildNotification(int id, JSONObject rawNotification, Context context,
NotificationController controller) throws Exception {
NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, rawNotification.getString("app"));
NotificationBuilderResult result = new NotificationBuilderResult(builder);
for(int i=0; i<processors.size(); ++i){
Log.d(TAG, "Will call notification processor: " + processors.get(i).toString());
result = processors.get(i).updateNotification(id, result, mNotificationManager,
rawNotification, context, controller);
}
return result;
}
public void addProcessor(AbstractNotificationProcessor processor){
int place=0;
if(processors.size() == 0){
Log.w(TAG, "No processors are registered. Resulting notification would be likely invalid");
}
for(;place<processors.size(); ++place){
if(processors.get(place).getPriority()>=processor.getPriority()){
break;
}
}
processors.insertElementAt(processor, place);
}
public void onNotificationEvent(NotificationEvent event, Intent intent,
NotificationController service) {
for(AbstractNotificationProcessor processor: processors){
processor.onNotificationEvent(event, intent, service);
}
}
}

24
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationBuilderResult.java Normal file
View file

@ -0,0 +1,24 @@
package com.polar.nextcloudservices.Notification;
import android.app.Notification;
import android.os.Bundle;
import androidx.core.app.NotificationCompat;
public class NotificationBuilderResult {
public NotificationControllerExtData extraData;
public NotificationCompat.Builder builder;
public NotificationBuilderResult(NotificationCompat.Builder builder){
this.builder = builder;
this.extraData = new NotificationControllerExtData();
}
public Notification getNotification(){
return builder.build();
}
public NotificationControllerExtData getExtraData(){
return extraData;
}
}

17
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationConfig.java Normal file
View file

@ -0,0 +1,17 @@
package com.polar.nextcloudservices.Notification;
import com.polar.nextcloudservices.Notification.Processors.ActionsNotificationProcessor;
import com.polar.nextcloudservices.Notification.Processors.basic.BasicNotificationProcessor;
import com.polar.nextcloudservices.Notification.Processors.OpenBrowserProcessor;
import com.polar.nextcloudservices.Notification.Processors.spreed.NextcloudTalkProcessor;
public class NotificationConfig {
public static final AbstractNotificationProcessor[] NOTIFICATION_PROCESSORS = {
new BasicNotificationProcessor(),
new NextcloudTalkProcessor(),
new OpenBrowserProcessor(),
new ActionsNotificationProcessor()
};
public static final String NOTIFICATION_CONTROLLER_EXT_DATA_KEY = "NotificationControllerExtData";
}

201
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationController.java Normal file
View file

@ -0,0 +1,201 @@
package com.polar.nextcloudservices.Notification;
import static android.content.Context.NOTIFICATION_SERVICE;
import android.annotation.SuppressLint;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import android.service.notification.StatusBarNotification;
import android.util.Log;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.core.app.NotificationCompat;
import com.polar.nextcloudservices.API.INextcloudAbstractAPI;
import com.polar.nextcloudservices.Config;
import com.polar.nextcloudservices.R;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import com.polar.nextcloudservices.Services.Status.Status;
import com.polar.nextcloudservices.Services.Status.StatusCheckable;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.HashSet;
import java.util.NoSuchElementException;
public class NotificationController implements NotificationEventReceiver, StatusCheckable {
private final HashSet<Integer> active_notifications = new HashSet<>();
private final NotificationBuilder mNotificationBuilder;
private final Context mContext;
private String mStatusString = "Updating settings";
private boolean isLastSendSuccessful = false;
private static final String TAG = "Notification.NotificationController";
private final NotificationManager mNotificationManager;
private final ServiceSettings mServiceSettings;
@SuppressLint("UnspecifiedRegisterReceiverFlag")
public NotificationController(Context context, ServiceSettings settings) {
mNotificationBuilder = new NotificationBuilder();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU){
context.getApplicationContext().registerReceiver(
new NotificationBroadcastReceiver(this),
new IntentFilter(Config.NotificationEventAction),
Context.RECEIVER_NOT_EXPORTED);
} else {
context.getApplicationContext().registerReceiver(
new NotificationBroadcastReceiver(this),
new IntentFilter(Config.NotificationEventAction));
}
mContext = context;
mNotificationManager =
(NotificationManager) mContext.getSystemService(NOTIFICATION_SERVICE);
mServiceSettings = settings;
registerNotificationProcessors();
}
@NonNull
public Notification getServiceNotification(){
//Create background service notifcation
String channelId = "__internal_backgorund_polling";
NotificationManager mNotificationManager =
(NotificationManager) mContext.getSystemService(NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(channelId,
"Background polling", NotificationManager.IMPORTANCE_LOW);
mNotificationManager.createNotificationChannel(channel);
}
//Build notification
NotificationCompat.Builder mBuilder =
new NotificationCompat.Builder(mContext, channelId)
.setSmallIcon(R.drawable.ic_logo)
.setContentTitle(mContext.getString(R.string.app_name))
.setPriority(-2)
.setOnlyAlertOnce(true)
.setContentText("Background connection notification");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
mBuilder.setChannelId(channelId);
}
return mBuilder.build();
}
private void registerNotificationProcessors(){
for(AbstractNotificationProcessor processor : NotificationConfig.NOTIFICATION_PROCESSORS){
mNotificationBuilder.addProcessor(processor);
}
}
private void sendNotification(int notification_id, JSONObject notification){
Log.d(TAG, "Sending notification:" + notification_id);
active_notifications.add(notification_id);
//FIXME: In worst case too many threads can be run
Thread thread = new Thread(() -> {
NotificationBuilderResult builderResult;
Notification aNotification;
int n_id = notification_id;
try {
builderResult = mNotificationBuilder.buildNotification(n_id,
notification, mContext, this);
aNotification = builderResult.getNotification();
NotificationControllerExtData data = builderResult.getExtraData();
if(data.needOverrideId()){
n_id = data.getNotificationId();
Log.d(TAG, "Overriding " + notification_id + " by " + n_id);
}
} catch (Exception e) {
Log.e(TAG, "Failed to parse notification");
e.printStackTrace();
return ;
}
Log.d(TAG, "Will post notification now");
mNotificationManager.notify(n_id, aNotification);
});
thread.start();
}
public void removeNotification(int notification_id){
if(notification_id < 0){
Log.w(TAG, "Got notification id which is negative, ignoring request");
return;
}
Log.d(TAG, "Removing notification " + Integer.valueOf(notification_id).toString());
mNotificationManager.cancel(notification_id);
synchronized (active_notifications) {
active_notifications.remove(notification_id);
}
}
public void onNotificationsUpdated(JSONObject response){
synchronized (active_notifications) {
try {
HashSet<Integer> remove_notifications = new HashSet<>(active_notifications);
int notification_id;
JSONArray notifications = response.getJSONObject("ocs").getJSONArray("data");
for (int i = 0; i < notifications.length(); ++i) {
JSONObject notification = notifications.getJSONObject(i);
notification_id = notification.getInt("notification_id");
remove_notifications.remove(notification_id);
if (!active_notifications.contains(notification_id)) {
//Handle notification
sendNotification(notification_id, notification);
}
}
for (int remove_id : remove_notifications) {
removeNotification(remove_id);
}
isLastSendSuccessful = true;
} catch (Exception e) {
mStatusString = "Disconnected: " + e.getLocalizedMessage();
isLastSendSuccessful = false;
e.printStackTrace();
}
}
}
public void onNotificationEvent(NotificationEvent event, Intent intent){
mNotificationBuilder.onNotificationEvent(event, intent, this);
}
@Override
public Status getStatus(Context context) {
if(!isLastSendSuccessful){
return Status.Failed(mStatusString);
}
return Status.Ok();
}
public void tellActionRequestFailed(){
Toast.makeText(mContext, R.string.quick_action_failed, Toast.LENGTH_LONG).show();
}
public Notification getNotificationById(int id) throws NoSuchElementException {
for(StatusBarNotification notification: mNotificationManager.getActiveNotifications()){
if(notification.getId() == id){
return notification.getNotification();
}
}
throw new NoSuchElementException("Can not find notification with specified id: " + id);
}
public void postNotification(int id, Notification notification){
mNotificationManager.notify(id, notification);
}
public INextcloudAbstractAPI getAPI(){
return mServiceSettings.getAPIFromSettings();
}
public Context getContext(){
return mContext;
}
public ServiceSettings getServiceSettings(){
return mServiceSettings;
}
}

66
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationControllerExtData.java Normal file
View file

@ -0,0 +1,66 @@
package com.polar.nextcloudservices.Notification;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;
public class NotificationControllerExtData implements Parcelable {
private static final String TAG = "Notification.NotificationControllerExtData";
private boolean id_override = false;
private int notification_id_override = -1;
protected NotificationControllerExtData(Parcel in) {
id_override = in.readByte() != 0;
notification_id_override = in.readInt();
}
public NotificationControllerExtData(){
/* STUB */
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeByte((byte) (id_override ? 1 : 0));
dest.writeInt(notification_id_override);
}
@Override
public int describeContents() {
return 0;
}
public static final Creator<NotificationControllerExtData> CREATOR = new Creator<NotificationControllerExtData>() {
@Override
public NotificationControllerExtData createFromParcel(Parcel in) {
return new NotificationControllerExtData(in);
}
@Override
public NotificationControllerExtData[] newArray(int size) {
return new NotificationControllerExtData[size];
}
};
public boolean needOverrideId(){
return id_override;
}
public int getNotificationId(){
return notification_id_override;
}
public void setNotificationIdOverride(int id){
if(id_override){
Log.w(TAG, "Overriding notification id " + id + " which is already overriden");
}
id_override = true;
notification_id_override = id;
}
public Bundle asBundle(){
Bundle bundle = new Bundle();
bundle.putParcelable(NotificationConfig.NOTIFICATION_CONTROLLER_EXT_DATA_KEY, this);
return bundle;
}
}

28
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationEvent.java Normal file
View file

@ -0,0 +1,28 @@
package com.polar.nextcloudservices.Notification;
public enum NotificationEvent {
NOTIFICATION_EVENT_UNKNOWN(0),
NOTIFICATION_EVENT_DELETE(1),
NOTIFICATION_EVENT_FASTREPLY(2),
NOTIFICATION_EVENT_CUSTOM_ACTION(3);
public final int value;
NotificationEvent(int _value){
value = _value;
}
static public NotificationEvent fromInt(int code){
switch (code){
case 0:
return NOTIFICATION_EVENT_UNKNOWN;
case 1:
return NOTIFICATION_EVENT_DELETE;
case 2:
return NOTIFICATION_EVENT_FASTREPLY;
case 3:
return NOTIFICATION_EVENT_CUSTOM_ACTION;
default:
throw new RuntimeException("Bad event code: " + code);
}
}
}

7
app/src/main/java/com/polar/nextcloudservices/Notification/NotificationEventReceiver.java Normal file
View file

@ -0,0 +1,7 @@
package com.polar.nextcloudservices.Notification;
import android.content.Intent;
public interface NotificationEventReceiver {
void onNotificationEvent(NotificationEvent event_type, Intent intent);
}

129
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/ActionsNotificationProcessor.java Normal file
View file

@ -0,0 +1,129 @@
package com.polar.nextcloudservices.Notification.Processors;
import static com.polar.nextcloudservices.Notification.NotificationEvent.NOTIFICATION_EVENT_CUSTOM_ACTION;
import android.annotation.SuppressLint;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.core.app.NotificationCompat;
import com.polar.nextcloudservices.Config;
import com.polar.nextcloudservices.Notification.AbstractNotificationProcessor;
import com.polar.nextcloudservices.Notification.NotificationBuilderResult;
import com.polar.nextcloudservices.Notification.NotificationController;
import com.polar.nextcloudservices.Notification.NotificationEvent;
import com.polar.nextcloudservices.Utils.CommonUtil;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class ActionsNotificationProcessor implements AbstractNotificationProcessor {
public static final int priority = 2;
private static final String TAG = "Notification.Processors.ActionsNotificationProcessor";
private static final String[] IGNORED_APPS = {"spreed"};
@SuppressLint("UnspecifiedImmutableFlag")
private static PendingIntent getCustomActionIntent(Context context,
JSONObject action, int requestCode){
Intent intent = new Intent();
intent.setAction(Config.NotificationEventAction);
try {
intent.putExtra("notification_event", NOTIFICATION_EVENT_CUSTOM_ACTION);
String link = action.getString("link");
final String type = action.getString("type");
link = CommonUtil.cleanUpURLIfNeeded(link);
if(link == null){
Log.e(TAG, "Nextcloud provided bad link for action");
return null;
}
intent.putExtra("action_link", link);
intent.putExtra("action_method", type);
} catch (JSONException e) {
Log.e(TAG, "Can not get link or method from action provided by Nextcloud API");
e.printStackTrace();
return null;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
return PendingIntent.getBroadcast(
context,
requestCode,
intent,
PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
);
}else{
return PendingIntent.getBroadcast(
context,
requestCode,
intent,
PendingIntent.FLAG_UPDATE_CURRENT
);
}
}
@Override
public NotificationBuilderResult updateNotification(int id, NotificationBuilderResult builderResult,
NotificationManager manager,
@NonNull JSONObject rawNotification,
Context context,
NotificationController controller) throws Exception {
final String appName = rawNotification.getString("app");
if (CommonUtil.isInArray(appName, IGNORED_APPS)) {
Log.d(TAG, appName + " is ignored");
return builderResult;
} else {
Log.d(TAG, appName + " is not ignored");
}
if(!rawNotification.has("actions")){
return builderResult;
}
JSONArray actions = rawNotification.getJSONArray("actions");
final int n_actions = actions.length();
for(int i = 0; i < n_actions; ++i){
JSONObject action = actions.getJSONObject(i);
PendingIntent actionPendingIntent = getCustomActionIntent(context, action, i);
if(actionPendingIntent == null){
Log.w(TAG, "Can not create action for notification");
return builderResult;
}
final String actionTitle = action.getString("label");
NotificationCompat.Action notificationAction = new NotificationCompat.Action.Builder(
null,
actionTitle, actionPendingIntent)
.build();
builderResult.builder.addAction(notificationAction);
}
return builderResult;
}
@Override
public void onNotificationEvent(NotificationEvent event, Intent intent,
NotificationController controller) {
if(event == NOTIFICATION_EVENT_CUSTOM_ACTION){
final String link = intent.getStringExtra("action_link");
final String method = intent.getStringExtra("action_method");
Log.d(TAG, method + " " + link);
Thread thread = new Thread(() -> {
try {
controller.getAPI().sendAction(link, method);
} catch (Exception e) {
Log.e(TAG, e.toString());
controller.tellActionRequestFailed();
}
});
thread.start();
}
}
@Override
public int getPriority() {
return priority;
}
}

71
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/OpenBrowserProcessor.java Normal file
View file

@ -0,0 +1,71 @@
package com.polar.nextcloudservices.Notification.Processors;
// This processor is default processor for user click event
// It is used to open web page and has priority 1
// So it is executed first and can be overriden by per-app processors
import android.annotation.SuppressLint;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.util.Log;
import androidx.browser.customtabs.CustomTabsIntent;
import com.polar.nextcloudservices.Notification.AbstractNotificationProcessor;
import com.polar.nextcloudservices.Notification.NotificationBuilderResult;
import com.polar.nextcloudservices.Notification.NotificationController;
import com.polar.nextcloudservices.Notification.NotificationEvent;
import org.json.JSONException;
import org.json.JSONObject;
public class OpenBrowserProcessor implements AbstractNotificationProcessor {
public final int priority = 1;
private static final String TAG = "Notification.Processors.OpenBrowserProcessor";
@Override
public NotificationBuilderResult updateNotification(int id, NotificationBuilderResult builderResult,
NotificationManager manager,
JSONObject rawNotification,
Context context, NotificationController controller) throws JSONException {
if (!rawNotification.has("link")) {
return builderResult;
}
Log.d(TAG, "Setting link for browser opening");
CustomTabsIntent browserIntent = new CustomTabsIntent.Builder()
.setUrlBarHidingEnabled(true)
.setShowTitle(false)
.setStartAnimations(context, android.R.anim.fade_in, android.R.anim.fade_out)
.setExitAnimations(context, android.R.anim.fade_in, android.R.anim.fade_out)
.setColorScheme(CustomTabsIntent.COLOR_SCHEME_SYSTEM)
.setShareState(CustomTabsIntent.SHARE_STATE_OFF)
.build();
browserIntent.intent.setData(Uri.parse(rawNotification.getString("link")));
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
builderResult.builder = builderResult.builder.setContentIntent(PendingIntent.getActivity(context, 0,
browserIntent.intent, PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT));
}else{
builderResult.builder = builderResult.builder.setContentIntent(PendingIntent.getActivity(context, 0,
browserIntent.intent, PendingIntent.FLAG_UPDATE_CURRENT));
}
return builderResult;
}
@Override
public void onNotificationEvent(NotificationEvent event, Intent intent, NotificationController controller) {
}
@Override
public int getPriority() {
return priority;
}
}

78
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/basic/AppNameMapper.java Normal file
View file

@ -0,0 +1,78 @@
package com.polar.nextcloudservices.Notification.Processors.basic;
import android.content.Context;
import com.polar.nextcloudservices.R;
import com.polar.nextcloudservices.Utils.CommonUtil;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* Maps Nextcloud app name to prettified name of app
*/
public class AppNameMapper {
/**
* Array of apps which have mapped names
*/
public static final String[] MAPPABLE_APPS = {"spreed",
"updatenotification", "twofactor_nextcloud_notification"};
/**
* A map mapping the mappable apps to resource id
*/
public static final Map<String, Integer> APP_TO_RESID_MAPPING;
static {
// Put app mapping here
Map<String, Integer> aMap = new HashMap<>();
aMap.put("spreed", R.string.spreed_name);
aMap.put("updatenotification", R.string.updatenotification_name);
aMap.put("twofactor_nextcloud_notification", R.string.twofactor_nextcloud_notification_name);
APP_TO_RESID_MAPPING = Collections.unmodifiableMap(aMap);
}
/**
* @param appName Nextcloud app name
* @return whether mapping to prettified name exists for provided app name
*/
public static boolean isAppMappable(String appName){
return CommonUtil.isInArray(appName, MAPPABLE_APPS);
}
/**
* @param context Android context
* @param appName Nextcloud app name
* @return prettified app name from mapping
* @throws RuntimeException if app has no prettified mapping
*/
public static String getPrettifiedAppNameFromMapping(Context context, String appName){
Integer result = APP_TO_RESID_MAPPING.get(appName);
if(result == null){
throw new RuntimeException("No entry for mapping app " + appName + " found");
}
return context.getString(result);
}
/**
* Get prettified app name from mapping if exists, tries to prettify if not
* @param context Android context
* @param appName Nextcloud app name
* @return prettified name of app
*/
public static String getPrettifiedAppName(Context context, String appName){
if(isAppMappable(appName)){
return getPrettifiedAppNameFromMapping(context, appName);
}
String[] parts = appName.split("_");
StringBuilder nice_name = new StringBuilder();
for (String part : parts) {
nice_name.append(part).append(" ");
}
String result = nice_name.toString();
result = Character.toUpperCase(result.charAt(0)) + result.substring(1);
return result;
}
}

141
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/basic/BasicNotificationProcessor.java Normal file
View file

@ -0,0 +1,141 @@
package com.polar.nextcloudservices.Notification.Processors.basic;
import static com.polar.nextcloudservices.Notification.NotificationEvent.NOTIFICATION_EVENT_DELETE;
import android.annotation.SuppressLint;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.util.Log;
import com.polar.nextcloudservices.Notification.AbstractNotificationProcessor;
import com.polar.nextcloudservices.Config;
import com.polar.nextcloudservices.Notification.NotificationBuilderResult;
import com.polar.nextcloudservices.Notification.NotificationController;
import com.polar.nextcloudservices.Notification.NotificationEvent;
import com.polar.nextcloudservices.R;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import org.json.JSONException;
import org.json.JSONObject;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class BasicNotificationProcessor implements AbstractNotificationProcessor {
public final int priority = 0;
private final static String TAG = "Notification.Processors.BasicNotificationProcessor";
public int iconByApp(String appName) {
switch (appName) {
case "spreed":
return R.drawable.ic_icon_foreground;
case "deck":
return R.drawable.ic_deck;
case "twofactor_nextcloud_notification":
return android.R.drawable.ic_partial_secure;
default:
return R.drawable.ic_logo;
}
}
@SuppressLint("UnspecifiedImmutableFlag")
private PendingIntent createNotificationDeleteIntent(Context context, int id) {
Intent intent = new Intent();
intent.setAction(Config.NotificationEventAction);
intent.putExtra("notification_id", id);
intent.putExtra("notification_event", NOTIFICATION_EVENT_DELETE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
return PendingIntent.getBroadcast(
context,
id,
intent,
PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
);
} else {
return PendingIntent.getBroadcast(
context,
id,
intent,
PendingIntent.FLAG_UPDATE_CURRENT
);
}
}
@Override
public NotificationBuilderResult updateNotification(int id, NotificationBuilderResult builderResult,
NotificationManager manager,
JSONObject rawNotification,
Context context,
NotificationController controller) throws JSONException {
final ServiceSettings settings = new ServiceSettings(context);
final boolean removeOnDismiss = settings.isRemoveOnDismissEnabled();
final String app = AppNameMapper.getPrettifiedAppName(context,
rawNotification.getString("app"));
final String title = rawNotification.getString("subject");
final String text = rawNotification.getString("message");
final String app_name = rawNotification.getString("app");
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(app_name, app, NotificationManager.IMPORTANCE_HIGH);
Log.i(TAG, "Creating channel " + app_name);
manager.createNotificationChannel(channel);
}
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
final String dateStr = rawNotification.getString("datetime");
long unixTime = 0;
try {
Date date = format.parse(dateStr);
if(date == null){
throw new ParseException("Date was not parsed: result is null", 0);
}
unixTime = date.getTime();
} catch (ParseException e) {
e.printStackTrace();
}
builderResult.builder = builderResult.builder.setSmallIcon(iconByApp(app_name))
.setContentTitle(title)
.setAutoCancel(true)
.setContentText(text)
.setChannelId(app_name);
if(unixTime != 0){
builderResult.builder.setWhen(unixTime);
}else{
Log.w(TAG, "unixTime is 0, maybe parse failure?");
}
if(removeOnDismiss){
Log.d(TAG, "Adding intent for delete notification event");
builderResult.builder = builderResult.builder.setDeleteIntent(createNotificationDeleteIntent(context,
rawNotification.getInt("notification_id")));
}
return builderResult;
}
@Override
public void onNotificationEvent(NotificationEvent event, Intent intent,
NotificationController controller) {
if(event != NOTIFICATION_EVENT_DELETE){
return;
}
int id = intent.getIntExtra("notification_id", -1);
Log.d(TAG, "Should remove notification " + id);
if(id < 0){
Log.wtf(TAG, "Notification delete event has not provided an id of notification deleted!");
}
Thread thread = new Thread(() -> callRemoveNotification(controller, id));
thread.start();
}
private void callRemoveNotification(NotificationController controller, int id){
controller.getAPI().removeNotification(id);
}
@Override
public int getPriority() {
return priority;
}
}

353
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/spreed/NextcloudTalkProcessor.java Normal file
View file

@ -0,0 +1,353 @@
package com.polar.nextcloudservices.Notification.Processors.spreed;
import static com.polar.nextcloudservices.Notification.NotificationEvent.NOTIFICATION_EVENT_DELETE;
import static com.polar.nextcloudservices.Notification.NotificationEvent.NOTIFICATION_EVENT_FASTREPLY;
import android.annotation.SuppressLint;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.browser.customtabs.CustomTabsIntent;
import androidx.core.app.NotificationCompat;
import androidx.core.app.Person;
import androidx.core.app.RemoteInput;
import androidx.core.graphics.drawable.IconCompat;
import com.polar.nextcloudservices.API.INextcloudAbstractAPI;
import com.polar.nextcloudservices.Config;
import com.polar.nextcloudservices.Notification.AbstractNotificationProcessor;
import com.polar.nextcloudservices.Notification.NotificationBuilderResult;
import com.polar.nextcloudservices.Notification.NotificationController;
import com.polar.nextcloudservices.Notification.NotificationEvent;
import com.polar.nextcloudservices.Notification.Processors.spreed.chat.Chat;
import com.polar.nextcloudservices.Notification.Processors.spreed.chat.ChatController;
import com.polar.nextcloudservices.Notification.Processors.spreed.chat.ChatMessage;
import com.polar.nextcloudservices.R;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import com.polar.nextcloudservices.Utils.CommonUtil;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Objects;
public class NextcloudTalkProcessor implements AbstractNotificationProcessor {
public final int priority = 2;
private static final String TAG = "Notification.Processors.NextcloudTalkProcessor";
private static final String KEY_TEXT_REPLY = "key_text_reply";
private final ChatController mChatController;
public NextcloudTalkProcessor() {
mChatController = new ChatController();
}
@SuppressLint("UnspecifiedImmutableFlag")
static private PendingIntent getReplyIntent(Context context,
@NonNull JSONObject rawNotification) throws JSONException {
Intent intent = new Intent();
int notification_id = rawNotification.getInt("notification_id");
intent.setAction(Config.NotificationEventAction);
intent.putExtra("notification_id", rawNotification.getInt("notification_id"));
intent.putExtra("notification_event", NOTIFICATION_EVENT_FASTREPLY);
String[] link = rawNotification.getString("link").split("/"); // use provided link to extract talk chatroom id
intent.putExtra("talk_chatroom", CommonUtil.cleanUpURLParams(link[link.length-1]));
intent.putExtra("talk_link", CommonUtil.cleanUpURLParams(rawNotification.getString("link")));
intent.setPackage(context.getPackageName()); // Issue 78 --> https://developer.android.com/about/versions/14/behavior-changes-14?hl=en#safer-intents
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
return PendingIntent.getBroadcast(
context,
notification_id,
intent,
PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
);
}else{
return PendingIntent.getBroadcast(
context,
notification_id,
intent,
PendingIntent.FLAG_UPDATE_CURRENT
);
}
}
private Person getUserPerson(){
Person.Builder builder = new Person.Builder();
builder.setName("You");
return builder.build();
}
@NonNull
private Person getPersonFromNotification(@NonNull NotificationController controller,
@NonNull JSONObject rawNotification) throws Exception {
Person.Builder builder = new Person.Builder();
if(rawNotification.getJSONObject("subjectRichParameters").has("user")){
JSONObject user = rawNotification.getJSONObject("subjectRichParameters")
.getJSONObject("user");
final String name = user.getString("name");
final String id = user.getString("id");
builder.setKey(id).setName(name);
Bitmap image = controller.getAPI().getUserAvatar(id);
IconCompat compat = IconCompat.createWithAdaptiveBitmap(image);
builder.setIcon(compat);
return builder.build();
}else {
final String key = rawNotification.getString("object_id");
builder.setKey(key);
final String name = rawNotification.getJSONObject("subjectRichParameters")
.getJSONObject("call").getString("name");
//NOTE: Nextcloud Talk does not seem to provide ability for setting avatar for calls
// so it is not fetched here
return builder.setName(name).build();
}
}
private NotificationCompat.Builder setCustomTabsIntent(Context context,
NotificationCompat.Builder builder,
String link) {
CustomTabsIntent browserIntent = new CustomTabsIntent.Builder()
.setUrlBarHidingEnabled(true)
.setShowTitle(false)
.setStartAnimations(context, android.R.anim.fade_in, android.R.anim.fade_out)
.setExitAnimations(context, android.R.anim.fade_in, android.R.anim.fade_out)
.setColorScheme(CustomTabsIntent.COLOR_SCHEME_SYSTEM)
.setShareState(CustomTabsIntent.SHARE_STATE_OFF)
.build();
browserIntent.intent.setData(Uri.parse(link));
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
return builder.setContentIntent(PendingIntent.getActivity(context, 0,
browserIntent.intent,
PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT));
}else{
return builder.setContentIntent(PendingIntent.getActivity(context, 0,
browserIntent.intent, PendingIntent.FLAG_UPDATE_CURRENT));
}
}
private NotificationCompat.Builder setTalkOpenIntent(Context context,
NotificationCompat.Builder builder){
PackageManager pm = context.getPackageManager();
if (!CommonUtil.isPackageInstalled("com.nextcloud.talk2", pm)) {
Log.w(TAG, "Expected to find com.nextcloud.talk2 installed, but package was not found");
return builder;
}
Log.d(TAG, "Setting up talk notification open intent");
Intent intent = pm.getLaunchIntentForPackage("com.nextcloud.talk2");
PendingIntent pending_intent;
pending_intent = PendingIntent.getActivity(context, 0, intent,
PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
return builder.setContentIntent(pending_intent);
}
private NotificationCompat.Builder setOpenIntent(NotificationController controller,
NotificationCompat.Builder builder,
Context context, String link){
ServiceSettings settings = controller.getServiceSettings();
if(settings == null){
Log.wtf(TAG, "settings is null!");
throw new RuntimeException("controller.getServiceSettings() returned null");
}
if(settings.getSpreedOpenedInBrowser()){
return setCustomTabsIntent(context, builder, link);
} else {
PackageManager pm = context.getPackageManager();
if (!CommonUtil.isPackageInstalled("com.nextcloud.talk2", pm)) {
Log.w(TAG, "Expected to find com.nextcloud.talk2 installed, but package was not found");
return setCustomTabsIntent(context, builder, link);
}
return setTalkOpenIntent(context, builder);
}
}
private NotificationBuilderResult setMessagingChatStyle(NotificationController controller,
NotificationBuilderResult builderResult,
@NonNull JSONObject rawNotification) throws Exception {
Person person = getPersonFromNotification(controller, rawNotification);
final String room = CommonUtil.cleanUpURLParams(rawNotification.getString("link"));
final String title = rawNotification.getJSONObject("subjectRichParameters")
.getJSONObject("call").getString("name");
final String text = rawNotification.getString("message");
int nc_notification_id = rawNotification.getInt("notification_id");
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'+00:00'");
final String dateStr = rawNotification.getString("datetime");
long unixTime = 0;
try {
Date date = format.parse(dateStr);
if (date == null) {
throw new ParseException("Date was not parsed: result is null", 0);
}
unixTime = date.getTime();
} catch (ParseException e) {
e.printStackTrace();
}
mChatController.onNewMessageReceived(room, text, person, unixTime, nc_notification_id);
NotificationCompat.MessagingStyle style = new NotificationCompat.MessagingStyle(person);
style = mChatController.addChatRoomMessagesToStyle(style, room);
style.setConversationTitle(title);
int notification_id = mChatController.getNotificationIdByRoom(room);
builderResult.extraData.setNotificationIdOverride(notification_id);
builderResult.builder = builderResult.builder.setStyle(style);
return builderResult;
}
@SuppressLint("UnspecifiedImmutableFlag")
@Override
public NotificationBuilderResult updateNotification(int id, NotificationBuilderResult builderResult,
NotificationManager manager,
@NonNull JSONObject rawNotification,
Context context, NotificationController controller) throws Exception {
if (!rawNotification.getString("app").equals("spreed")) {
return builderResult;
}
Log.d(TAG, "Setting up talk notification");
if (rawNotification.has("object_type")) {
if (rawNotification.getString("object_type").equals("chat")) {
Log.d(TAG, "Talk notification of chat type, adding fast reply button");
String replyLabel = context.getString(R.string.talk_fast_reply);
RemoteInput remoteInput = new RemoteInput.Builder(KEY_TEXT_REPLY)
.setLabel(replyLabel)
.build();
PendingIntent replyPendingIntent = getReplyIntent(context, rawNotification);
final String fastreply_title = context.getString(R.string.talk_fast_reply);
NotificationCompat.Action action =
new NotificationCompat.Action.Builder(R.drawable.ic_reply_icon,
fastreply_title, replyPendingIntent)
.addRemoteInput(remoteInput)
.setAllowGeneratedReplies(true)
.build();
builderResult.builder.addAction(action);
if (rawNotification.getString("messageRich").equals("{file}") && rawNotification
.getJSONObject("messageRichParameters")
.getJSONObject("file")
.getString("mimetype").startsWith("image/")) {
Bitmap imagePreview = controller.getAPI().getImagePreview(rawNotification
.getJSONObject("messageRichParameters")
.getJSONObject("file").getString("id"));
builderResult.builder.setStyle(new NotificationCompat.BigPictureStyle()
.bigPicture(imagePreview));
} else {
setMessagingChatStyle(controller, builderResult,
rawNotification);
}
}
}
builderResult.builder = setOpenIntent(controller, builderResult.builder, context,
rawNotification.getString("link"));
return builderResult;
}
private void onFastReply(Intent intent, NotificationController controller){
final String chatroom =
CommonUtil.cleanUpURLParams(
Objects.requireNonNull(intent.getStringExtra("talk_chatroom"))); // the string send by spreed is chatroomid
final String chatroom_link = CommonUtil.cleanUpURLParams(
Objects.requireNonNull(intent.getStringExtra("talk_link")));
final int notification_id = intent.getIntExtra("notification_id", -1);
if (notification_id < 0) {
Log.wtf(TAG, "Bad notification id: " + notification_id);
return;
}
Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
if (remoteInput == null) {
Log.e(TAG, "Reply event has null reply text");
return;
}
final String reply =
Objects.requireNonNull(remoteInput.getCharSequence(KEY_TEXT_REPLY)).toString();
INextcloudAbstractAPI api = controller.getAPI();
Thread thread = new Thread(() -> {
try {
api.sendTalkReply(chatroom, reply);
appendQuickReply(controller,
mChatController.getNotificationIdByRoom(chatroom_link), reply);
} catch (Exception e) {
Log.e(TAG, e.toString());
e.printStackTrace();
///controller.tellActionRequestFailed();
}
});
thread.start();
}
private void onDeleteNotification(Intent intent, NotificationController controller){
//NOTE: we actually can not get here if remove on dismiss disabled
// so we may safely ignore checking settings
final int notification_id = intent.getIntExtra("notification_id", -1);
if(notification_id == -1){
Log.e(TAG, "Invalid notification id, can not properly handle notification deletion");
return;
}
Chat chat = mChatController.getChatByNotificationId(notification_id);
if(chat == null){
Log.wtf(TAG, "Can not find chat by notification id " + notification_id);
return;
}
INextcloudAbstractAPI api = controller.getAPI();
for(ChatMessage message : chat.messages){
Thread thread = new Thread(() -> {
try {
api.removeNotification(message.notification_id);
} catch (Exception e) {
Log.e(TAG, e.toString());
}
});
thread.start();
}
mChatController.removeChat(chat);
}
@Override
public void onNotificationEvent(NotificationEvent event, Intent intent,
NotificationController controller) {
if (event == NOTIFICATION_EVENT_FASTREPLY) {
onFastReply(intent, controller);
} else if(event == NOTIFICATION_EVENT_DELETE){
onDeleteNotification(intent, controller);
}
}
private void appendQuickReply(NotificationController controller,
int notification_id, String text){
Notification notification = controller.getNotificationById(notification_id);
Context context = controller.getContext();
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, notification);
NotificationCompat.MessagingStyle style = NotificationCompat
.MessagingStyle.extractMessagingStyleFromNotification(notification);
if(style == null){
Log.wtf(TAG, "appendQuickReply: got null style");
return;
}
style.addMessage(text, CommonUtil.getTimestamp(), getUserPerson());
final String room = mChatController.getChatByNotificationId(notification_id).room;
mChatController.onNewMessageReceived(room, text, getUserPerson(),
CommonUtil.getTimestamp(), -1);
notification = builder.setStyle(style).build();
controller.postNotification(notification_id, notification);
}
@Override
public int getPriority() {
return priority;
}
}

22
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/spreed/chat/Chat.java Normal file
View file

@ -0,0 +1,22 @@
package com.polar.nextcloudservices.Notification.Processors.spreed.chat;
import androidx.core.app.Person;
import java.util.Vector;
public class Chat {
public final Vector<ChatMessage> messages;
public String room;
public Integer nc_notification_id;
public Chat(Integer nc_notification_id, String room) {
this.nc_notification_id = nc_notification_id;
messages = new Vector<>();
this.room = room;
}
public void onNewMessage(String text, Person person, long timestamp, int nc_notification_id){
messages.add(new ChatMessage(text, person, timestamp, nc_notification_id));
}
}

97
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/spreed/chat/ChatController.java Normal file
View file

@ -0,0 +1,97 @@
package com.polar.nextcloudservices.Notification.Processors.spreed.chat;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.core.app.NotificationCompat;
import androidx.core.app.Person;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.NoSuchElementException;
/**
* A generic controller of a chat logic.
* It stores a history of messages per converstation and also allows to cancel, i.e.
* remove conversation by message id.
*/
public class ChatController {
private final HashMap<String, Chat> chat_by_room;
private final HashMap<Integer, Chat> chat_by_notification_id;
private final HashMap<String, Integer> notification_id_by_room;
private final static String TAG = "ChatController";
public ChatController() {
chat_by_room = new HashMap<>();
chat_by_notification_id = new HashMap<>();
notification_id_by_room = new HashMap<>();
}
private Chat getChat(String room, int nc_notification_id){
if(!chat_by_room.containsKey(room)){
Chat chat = new Chat(nc_notification_id, room);
chat_by_room.put(room, chat);
chat_by_notification_id.put(nc_notification_id, chat);
notification_id_by_room.put(room, nc_notification_id);
}
return chat_by_room.get(room);
}
public @NonNull Integer getNotificationIdByRoom(String room) throws NoSuchElementException{
if(!notification_id_by_room.containsKey(room)){
throw new NoSuchElementException("Can not find room: " + room);
}
return notification_id_by_room.get(room);
}
public void onNewMessageReceived(String room, String text,
Person person,
long timestamp, int nc_notification_id){
synchronized (chat_by_room) {
Chat chat = getChat(room, nc_notification_id);
chat.onNewMessage(text, person, timestamp, nc_notification_id);
chat_by_notification_id.put(nc_notification_id, chat);
}
}
public Chat getChatByRoom(String room){
return chat_by_room.get(room);
}
public NotificationCompat.MessagingStyle addChatRoomMessagesToStyle(NotificationCompat.MessagingStyle style,
String room){
Chat chat = chat_by_room.get(room);
if(chat == null){
Log.wtf(TAG, "Requested non-existent room or null is in chat_by_room map");
return null;
}
synchronized (chat.messages) {
List<ChatMessage> cMessages = chat.messages;
Collections.sort(cMessages);
for (ChatMessage message : cMessages) {
style = style.addMessage(message.text, message.timestamp, message.person);
}
}
return style;
}
public Chat getChatByNotificationId(Integer notification_id){
return chat_by_notification_id.get(notification_id);
}
public void removeChat(@NonNull Chat chat){
synchronized (chat_by_room){
chat_by_room.remove(chat.room);
}
synchronized (chat_by_notification_id){
for(ChatMessage message : chat.messages){
chat_by_notification_id.remove(message.notification_id);
}
}
synchronized (notification_id_by_room){
notification_id_by_room.remove(chat.room);
}
}
}

22
app/src/main/java/com/polar/nextcloudservices/Notification/Processors/spreed/chat/ChatMessage.java Normal file
View file

@ -0,0 +1,22 @@
package com.polar.nextcloudservices.Notification.Processors.spreed.chat;
import androidx.core.app.Person;
public class ChatMessage implements Comparable<ChatMessage> {
public String text;
public long timestamp;
public int notification_id;
public Person person;
public ChatMessage(String text, Person person, long timestamp, int notification_id) {
this.text = text;
this.timestamp = timestamp;
this.notification_id = notification_id;
this.person = person;
}
@Override
public int compareTo(ChatMessage o) {
return (int)(this.timestamp - o.timestamp);
}
}

72
app/src/main/java/com/polar/nextcloudservices/Services/ConnectionController.java Normal file
View file

@ -0,0 +1,72 @@
package com.polar.nextcloudservices.Services;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import com.polar.nextcloudservices.Services.Status.Status;
import com.polar.nextcloudservices.Services.Status.StatusCheckable;
/**
* Checks connectivity to the network
*/
public class ConnectionController implements StatusCheckable {
private final ServiceSettings mServiceSettings;
private final static String TAG = "Services.ConnectionController";
private BroadcastReceiver broadcastReceiver = null;
public ConnectionController(ServiceSettings settings){
mServiceSettings = settings;
}
public boolean checkConnection(Context context) {
ConnectivityManager connectivity =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivity != null) {
//We need to check only active network state
final NetworkInfo activeNetwork = connectivity.getActiveNetworkInfo();
if (activeNetwork != null) {
if (activeNetwork.isConnected()) {
if (activeNetwork.isRoaming()) {
//Log.d(TAG, "Network is in roaming");
return mServiceSettings.isRoamingConnectionAllowed();
} else if (connectivity.isActiveNetworkMetered()) {
//Log.d(TAG, "Network is metered");
return mServiceSettings.isMeteredConnectionAllowed();
} else {
//Log.d(TAG, "Network is unmetered");
return true;
}
}
}
}
return false;
}
@Override
public Status getStatus(Context context) {
if(checkConnection(context)){
return Status.Ok();
}
return Status.Failed("Disconnected: no suitable network found.");
}
public void setConnectionStatusListener(Context context, IConnectionStatusListener listener){
if(broadcastReceiver != null){
context.unregisterReceiver(broadcastReceiver);
}
broadcastReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
listener.onConnectionStatusChanged(checkConnection(context));
}};
context.registerReceiver(broadcastReceiver,
new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
}
public void removeConnectionListener(Context context){
context.unregisterReceiver(broadcastReceiver);
}
}

5
app/src/main/java/com/polar/nextcloudservices/Services/IConnectionStatusListener.java Normal file
View file

@ -0,0 +1,5 @@
package com.polar.nextcloudservices.Services;
public interface IConnectionStatusListener {
void onConnectionStatusChanged(boolean isConnected);
}

10
app/src/main/java/com/polar/nextcloudservices/Services/INotificationListener.java Normal file
View file

@ -0,0 +1,10 @@
package com.polar.nextcloudservices.Services;
import org.json.JSONObject;
/**
* An interface for delivering new notifications
*/
public interface INotificationListener {
void onNewNotifications(JSONObject response);
}

10
app/src/main/java/com/polar/nextcloudservices/Services/INotificationService.java Normal file
View file

@ -0,0 +1,10 @@
package com.polar.nextcloudservices.Services;
/**
* Interface for communicating with notification service from side of UI
*/
public interface INotificationService {
String getStatus();
void onPreferencesChanged();
void onAccountChanged();
}

170
app/src/main/java/com/polar/nextcloudservices/Services/NotificationPollService.java Normal file
View file

@ -0,0 +1,170 @@
package com.polar.nextcloudservices.Services;
import android.app.Service;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;
import org.json.JSONObject;
import java.util.Timer;
import java.util.TimerTask;
import com.polar.nextcloudservices.API.INextcloudAbstractAPI;
import com.polar.nextcloudservices.Notification.NotificationController;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import com.polar.nextcloudservices.Services.Status.StatusController;
class PollTask extends AsyncTask<NotificationPollService, Void, JSONObject> {
private static final String TAG = "Services.NotificationPollService.PollTask";
@Override
protected JSONObject doInBackground(NotificationPollService... services) {
Log.d(TAG, "Checking notifications");
INextcloudAbstractAPI api = services[0].getAPI();
try {
boolean hasNotifications = api.checkNewNotifications();
if(hasNotifications) {
return api.getNotifications(services[0]);
}
} catch (Exception e) {
Log.e(TAG, "Can not check new notifications");
e.printStackTrace();
}
return null;
}
}
public class NotificationPollService extends Service
implements INotificationListener, INotificationService {
// constant
public Integer pollingInterval = null;
public static final String TAG = "Services.NotificationPollService";
private NotificationServiceBinder mBinder;
private PollTimerTask task;
public INextcloudAbstractAPI mAPI;
private ServiceSettings mServiceSettings;
private ConnectionController mConnectionController;
private StatusController mStatusController;
private NotificationController mNotificationController;
// run on another Thread to avoid crash
private final Handler mHandler = new Handler();
// timer handling
private Timer mTimer = null;
@Override
public String getStatus() {
return mStatusController.getStatusString();
}
public void onNewNotifications(JSONObject response) {
if(response != null) {
mNotificationController.onNotificationsUpdated(response);
}
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
public void updateTimer() {
task.cancel();
mTimer.purge();
mTimer = new Timer();
task = new PollTimerTask();
mTimer.scheduleAtFixedRate(task, 0, pollingInterval);
}
private void startTimer(){
// cancel if already existed
if (mTimer != null) {
mTimer.cancel();
} else {
// recreate new
mTimer = new Timer();
}
// schedule task
task = new PollTimerTask();
mTimer.scheduleAtFixedRate(task, 0, pollingInterval);
}
public INextcloudAbstractAPI getAPI(){
if(mServiceSettings == null){
Log.wtf(TAG, "mServiceSettings is null!");
return null;
}
return mServiceSettings.getAPIFromSettings();
}
@Override
public void onCreate() {
mBinder = new NotificationServiceBinder(this);
mServiceSettings = new ServiceSettings(this);
mAPI = mServiceSettings.getAPIFromSettings();
pollingInterval = mServiceSettings.getPollingIntervalMs();
Log.d(TAG, "onCreate: Set polling interval to " + pollingInterval);
mConnectionController = new ConnectionController(mServiceSettings);
mNotificationController = new NotificationController(this, mServiceSettings);
mStatusController = new StatusController(this);
mStatusController.addComponent(NotificationServiceComponents.SERVICE_COMPONENT_CONNECTION,
mConnectionController, NotificationServiceConfig.CONNECTION_COMPONENT_PRIORITY);
mStatusController.addComponent(
NotificationServiceComponents.SERVICE_COMPONENT_NOTIFICATION_CONTROLLER,
mNotificationController,
NotificationServiceConfig.NOTIFICATION_CONTROLLER_PRIORITY);
mStatusController.addComponent(NotificationServiceComponents.SERVICE_COMPONENT_API,
mAPI, NotificationServiceConfig.API_COMPONENT_PRIORITY);
startTimer();
startForeground(1, mNotificationController.getServiceNotification());
}
@Override
public void onPreferencesChanged() {
mServiceSettings.onPreferencesChanged();
int _pollingInterval = mServiceSettings.getPollingIntervalMs();
onAccountChanged();
if (_pollingInterval != pollingInterval) {
Log.d(TAG, "Updating timer");
pollingInterval = _pollingInterval;
updateTimer();
}
}
@Override
public void onDestroy() {
Log.i(TAG, "Destroying service");
task.cancel();
mTimer.purge();
}
@Override
public void onAccountChanged(){
mAPI = mServiceSettings.getAPIFromSettings();
mStatusController.addComponent(NotificationServiceComponents.SERVICE_COMPONENT_API, mAPI,
NotificationServiceConfig.CONNECTION_COMPONENT_PRIORITY);
}
class PollTimerTask extends TimerTask {
@Override
public void run() {
// run on another thread
mHandler.post(() -> {
if (mConnectionController.checkConnection(getApplicationContext())) {
new PollTask().execute(NotificationPollService.this);
}
});
}
}
}

23
app/src/main/java/com/polar/nextcloudservices/Services/NotificationServiceBinder.java Normal file
View file

@ -0,0 +1,23 @@
package com.polar.nextcloudservices.Services;
public class NotificationServiceBinder extends android.os.Binder {
private final INotificationService mNotificationService;
public NotificationServiceBinder(INotificationService service){
super();
mNotificationService = service;
}
// Returns current status string of a service
public String getServiceStatus() {
return mNotificationService.getStatus();
}
// Runs re-check of preferences, can be called from activities
public void onPreferencesChanged() {
mNotificationService.onPreferencesChanged();
}
// Update API class when accounts state change
public void onAccountChanged() {
mNotificationService.onAccountChanged();
}
}

8
app/src/main/java/com/polar/nextcloudservices/Services/NotificationServiceComponents.java Normal file
View file

@ -0,0 +1,8 @@
package com.polar.nextcloudservices.Services;
public class NotificationServiceComponents {
public static final Integer SERVICE_COMPONENT_API = 0x1;
public static final Integer SERVICE_COMPONENT_CONNECTION = 0x2;
public static final Integer SERVICE_COMPONENT_NOTIFICATION_CONTROLLER = 0x3;
public static final Integer SERVICE_COMPONENT_WEBSOCKET = 0x4;
}

7
app/src/main/java/com/polar/nextcloudservices/Services/NotificationServiceConfig.java Normal file
View file

@ -0,0 +1,7 @@
package com.polar.nextcloudservices.Services;
public class NotificationServiceConfig {
public static final Integer API_COMPONENT_PRIORITY = 2;
public static final Integer CONNECTION_COMPONENT_PRIORITY = 3;
public static final Integer NOTIFICATION_CONTROLLER_PRIORITY = 1;
}

84
app/src/main/java/com/polar/nextcloudservices/Services/NotificationServiceController.java Normal file
View file

@ -0,0 +1,84 @@
package com.polar.nextcloudservices.Services;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Build;
import android.util.Log;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
/**
* Implements logic of choosing between services
*/
public class NotificationServiceController {
private final ServiceSettings mServiceSettings;
private Class<?> lastServiceClass;
private static final String TAG = "Services.NotificationServiceController";
public NotificationServiceController(ServiceSettings serviceSettings){
mServiceSettings = serviceSettings;
lastServiceClass = getServiceClass();
}
public Class<?> getServiceClass(){
if(mServiceSettings.isWebsocketEnabled()){
return NotificationWebsocketService.class;
}else{
return NotificationPollService.class;
}
}
public void startService(Context context){
Class<?> serviceClass = getServiceClass();
Log.i(TAG, "Starting service...");
Log.d(TAG, "Class: " + serviceClass);
Intent intent = new Intent(context, serviceClass);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
context.startForegroundService(intent);
} else {
context.startService(intent);
}
}
public void stopService(Context context){
Log.i(TAG, "Stopping service...");
Class<?> serviceClass = getServiceClass();
Log.d(TAG, "Class: " + serviceClass);
if(serviceClass == null){
Log.w(TAG, "Can not stop service: we do not know its class");
return;
}
context.stopService(new Intent(context, serviceClass));
}
public void onServiceClassChange(Context context){
Log.d(TAG, "onServiceClassChange: old class = " + lastServiceClass);
Class<?> serviceClass = getServiceClass();
Log.d(TAG, "onServiceClassChange: new class = " + serviceClass);
if(lastServiceClass == serviceClass){
Log.w(TAG, "Service class is unchanged, doing nothing");
}
//Stop old service
Log.i(TAG, "Stopping service...");
Log.d(TAG, "Class: " + lastServiceClass);
context.stopService(new Intent(context, lastServiceClass));
lastServiceClass = serviceClass;
//Start new service
startService(context);
}
public void bindService(Context context, ServiceConnection connection){
Log.d(TAG, "binding service");
Class<?> serviceClass = getServiceClass();
context.bindService(new Intent(context, serviceClass),
connection, 0);
}
public void restartService(Context context){
Log.i(TAG, "Restarting service");
stopService(context);
startService(context);
}
}

175
app/src/main/java/com/polar/nextcloudservices/Services/NotificationWebsocketService.java Normal file
View file

@ -0,0 +1,175 @@
package com.polar.nextcloudservices.Services;
import android.app.Notification;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
import com.polar.nextcloudservices.API.INextcloudAbstractAPI;
import com.polar.nextcloudservices.API.websocket.NotificationWebsocket;
import com.polar.nextcloudservices.API.websocket.INotificationWebsocketEventListener;
import com.polar.nextcloudservices.Notification.NotificationController;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import com.polar.nextcloudservices.Services.Status.StatusController;
import com.polar.nextcloudservices.Utils.CommonUtil;
import org.json.JSONObject;
public class NotificationWebsocketService extends Service
implements INotificationWebsocketEventListener,
IConnectionStatusListener, INotificationService{
private INextcloudAbstractAPI mAPI;
private ServiceSettings mServiceSettings;
private NotificationController mNotificationController;
private ConnectionController mConnectionController;
private StatusController mStatusController;
private NotificationWebsocket mNotificationWebsocket;
private NotificationServiceBinder mBinder;
private Thread mWsThread;
private final static String TAG = "Services.NotificationWebsocketService";
@Override
public void onCreate(){
Log.d(TAG, "onCreate");
mServiceSettings = new ServiceSettings(this);
mNotificationController = new NotificationController(this, mServiceSettings);
mAPI = mServiceSettings.getAPIFromSettings();
mStatusController = new StatusController(this);
mConnectionController = new ConnectionController(mServiceSettings);
mStatusController.addComponent(NotificationServiceComponents.SERVICE_COMPONENT_CONNECTION,
mNotificationController,
NotificationServiceConfig.NOTIFICATION_CONTROLLER_PRIORITY);
mStatusController.addComponent(NotificationServiceComponents.SERVICE_COMPONENT_CONNECTION,
mConnectionController, NotificationServiceConfig.CONNECTION_COMPONENT_PRIORITY);
mConnectionController.setConnectionStatusListener(this, this);
mWsThread = new Thread(this::listenForever);
mWsThread.start();
Notification notification = mNotificationController.getServiceNotification();
startForeground(2, notification);
Log.d(TAG, "startForeground done");
mBinder = new NotificationServiceBinder(this);
}
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG, "onBind");
if(mBinder == null){
Log.e(TAG, "Binder is null!");
}
return mBinder;
}
@Override
public void onNewNotifications(JSONObject response) {
if(response != null){
mNotificationController.onNotificationsUpdated(response);
}else{
Log.e(TAG, "null response for notifications");
}
}
@Override
public void onConnectionStatusChanged(boolean isConnected){
if(mNotificationWebsocket == null){
Log.w(TAG, "Notification websocket is currently null. Ignoring connection state change.");
return;
}
if(!mNotificationWebsocket.getConnected() && isConnected){
Log.d(TAG, "Not connected: restarting connection");
mWsThread.interrupt();
mWsThread = new Thread(this::listenForever);
mWsThread.start();
}
}
private boolean startListening(){
try {
mNotificationWebsocket = mAPI.getNotificationsWebsocket(this);
mStatusController.addComponent(
NotificationServiceComponents.SERVICE_COMPONENT_WEBSOCKET,
mNotificationWebsocket, NotificationServiceConfig.API_COMPONENT_PRIORITY);
mAPI.getNotifications(this);
return true;
} catch (Exception e) {
Log.e(TAG, "Exception while starting listening:", e);
}
return false;
}
private void listenForever(){
for(;;){
if(mConnectionController.checkConnection(this)){
if(startListening()){
return;
}
} else {
Log.w(TAG, "We are not connected, not starting-up");
}
Log.i(TAG, "Restart pause 3s");
CommonUtil.safeSleep(3000);
}
}
/**
* @param isError whether disconnect resulted from error
*/
@Override
public void onWebsocketDisconnected(boolean isError) {
if(mConnectionController.checkConnection(this)){
Log.w(TAG, "Received disconnect from websocket. Restart pause 3 seconds");
CommonUtil.safeSleep(3000);
startListening();
} else {
Log.w(TAG, "Disconnected from websocket. Seems that we have no network");
//listenForever();
}
}
@Override
public void onWebsocketConnected() {
/* stub */
}
@Override
public String getStatus() {
if(!mConnectionController.checkConnection(this)){
return "Disconnected: no suitable network found";
}else if(mNotificationWebsocket == null){
return "Disconnected: can not connect to websocket. Are login details correct? Is notify_push installed on server?";
}
return mStatusController.getStatusString();
}
private void safeCloseWebsocket(){
if(mNotificationWebsocket != null){
mNotificationWebsocket.close();
}
}
@Override
public void onPreferencesChanged() {
safeCloseWebsocket();
if(!mServiceSettings.isWebsocketEnabled()){
Log.i(TAG, "Websocket is no more enabled. Disconnecting websocket and stopping service");
stopForeground(true);
}else{
Log.i(TAG, "Preferences changed. Re-connecting to websocket.");
mAPI = mServiceSettings.getAPIFromSettings();
}
}
@Override
public void onAccountChanged() {
Log.i(TAG, "Account changed. Re-connecting to websocket.");
mNotificationWebsocket.close();
mAPI = mServiceSettings.getAPIFromSettings();
startListening();
}
@Override
public void onDestroy(){
mConnectionController.removeConnectionListener(this);
super.onDestroy();
}
}

15
app/src/main/java/com/polar/nextcloudservices/Services/Settings/ServiceSettingConfig.java Normal file
View file

@ -0,0 +1,15 @@
package com.polar.nextcloudservices.Services.Settings;
public class ServiceSettingConfig {
public static final String ALLOW_METERED = "allow_metered";
public static final String ALLOW_ROAMING = "allow_roaming";
public static final String REMOVE_ON_DISMISS = "remove_on_dismiss";
public static final String POLLING_INTERVAL = "polling_interval";
public static final String USERNAME = "login";
public static final String PASSWORD = "password";
public static final String SERVER = "server";
public static final String USE_HTTP = "insecure_connection";
public static final String OPEN_SPREED_IN_BROWSER = "open_spreed_in_browser";
public static final String USE_WEBSOCKET = "use_websocket";
public static final String ENABLE_SERVICE = "enable_polling";
}

114
app/src/main/java/com/polar/nextcloudservices/Services/Settings/ServiceSettings.java Normal file
View file

@ -0,0 +1,114 @@
package com.polar.nextcloudservices.Services.Settings;
import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;
import androidx.preference.PreferenceManager;
import com.nextcloud.android.sso.model.SingleSignOnAccount;
import com.polar.nextcloudservices.API.INextcloudAbstractAPI;
import com.polar.nextcloudservices.API.NextcloudHttpAPI;
import com.polar.nextcloudservices.API.NextcloudSSOAPI;
/**
* Implements interface for accessing settings
*/
public class ServiceSettings {
private static final String TAG = "Services.Settings.ServiceSettings";
private final Context mContext;
private INextcloudAbstractAPI mCachedAPI = null;
public ServiceSettings(Context context){
mContext = context;
}
private INextcloudAbstractAPI makeAPIFromSettings(){
if (getBoolPreference("sso_enabled", false)) {
final String name = getPreference("sso_name");
final String server = getPreference("sso_server");
final String type = getPreference("sso_type");
final String token = getPreference("sso_token");
final String userId = getPreference("sso_userid");
final SingleSignOnAccount ssoAccount = new SingleSignOnAccount(name, userId, token, server, type);
return new NextcloudSSOAPI(mContext, ssoAccount);
} else {
//We do not have an account -> use HTTP API
Log.i(TAG, "No Nextcloud account was found.");
return new NextcloudHttpAPI(this);
}
}
public INextcloudAbstractAPI getAPIFromSettings(){
if(mCachedAPI == null){
mCachedAPI = makeAPIFromSettings();
}
return mCachedAPI;
}
public void onPreferencesChanged(){
mCachedAPI = makeAPIFromSettings();
}
public String getPreference(String key) {
SharedPreferences sharedPreferences =
PreferenceManager.getDefaultSharedPreferences(mContext);
return sharedPreferences.getString(key, "<none>");
}
public Integer getIntPreference(String key, int i) {
SharedPreferences sharedPreferences =
PreferenceManager.getDefaultSharedPreferences(mContext);
return sharedPreferences.getInt(key, Integer.MIN_VALUE);
}
public boolean getBoolPreference(String key, boolean fallback) {
SharedPreferences sharedPreferences =
PreferenceManager.getDefaultSharedPreferences(mContext);
return sharedPreferences.getBoolean(key, fallback);
}
public boolean isMeteredConnectionAllowed(){
return getBoolPreference(ServiceSettingConfig.ALLOW_METERED, false);
}
public boolean isRoamingConnectionAllowed(){
return getBoolPreference(ServiceSettingConfig.ALLOW_ROAMING, false);
}
public boolean isRemoveOnDismissEnabled() {
return getBoolPreference(ServiceSettingConfig.REMOVE_ON_DISMISS, false);
}
public int getPollingIntervalMs() {
return getIntPreference(ServiceSettingConfig.POLLING_INTERVAL, 10) * 1000;
}
public String getUsername() {
return getPreference(ServiceSettingConfig.USERNAME);
}
public String getPassword() {
return getPreference(ServiceSettingConfig.PASSWORD);
}
public String getServer() {
return getPreference(ServiceSettingConfig.SERVER);
}
public boolean getUseHttp(){
return getBoolPreference(ServiceSettingConfig.USE_HTTP, false);
}
public boolean getSpreedOpenedInBrowser(){
return getBoolPreference(ServiceSettingConfig.OPEN_SPREED_IN_BROWSER, true);
}
public boolean isWebsocketEnabled(){
return getBoolPreference(ServiceSettingConfig.USE_WEBSOCKET, false);
}
public boolean isServiceEnabled(){
return getBoolPreference(ServiceSettingConfig.ENABLE_SERVICE, true);
}
}

25
app/src/main/java/com/polar/nextcloudservices/Services/Status/Status.java Normal file
View file

@ -0,0 +1,25 @@
package com.polar.nextcloudservices.Services.Status;
/*
* Represents status of polling.
* Stores boolean indicating whether service connecting and working
* and a string reason why service has fault.
*/
public class Status {
public String reason;
public boolean isOk;
public Status(boolean _isOk, String _reason){
isOk = _isOk;
reason = _reason;
}
public static Status Ok(){
return new Status(true, null);
}
public static Status Failed(String reason){
return new Status(false, reason);
}
}

11
app/src/main/java/com/polar/nextcloudservices/Services/Status/StatusCheckable.java Normal file
View file

@ -0,0 +1,11 @@
package com.polar.nextcloudservices.Services.Status;
import android.content.Context;
public interface StatusCheckable {
/**
* @param context context which may be used for obtaining app and device status
* @return status information in form of Status class
*/
Status getStatus(Context context);
}

73
app/src/main/java/com/polar/nextcloudservices/Services/Status/StatusController.java Normal file
View file

@ -0,0 +1,73 @@
package com.polar.nextcloudservices.Services.Status;
import android.content.Context;
import android.util.Log;
import androidx.annotation.NonNull;
import java.lang.reflect.Array;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
/*
* Implements status-checking logic
*/
public class StatusController {
private static final String TAG = "Services.Status.StatusController";
private final HashMap<Integer, StatusCheckable> components;
private final HashMap<Integer, Integer> components_priority_mapping;
private final Context mContext;
public StatusController(Context context){
components = new HashMap<>();
mContext = context;
components_priority_mapping = new HashMap<>();
}
public void addComponent(@NonNull Integer componentId, @NonNull StatusCheckable component,
@NonNull Integer priority){
components.put(componentId, component);
components_priority_mapping.put(componentId, priority);
}
public void removeComponent(Integer componentId){
components.remove(componentId);
components_priority_mapping.remove(componentId);
}
public Status check(){
Integer maxPriority = Integer.MIN_VALUE;
Status status = Status.Ok();
for(Integer componentId: components.keySet()){
StatusCheckable component = components.get(componentId);
if(component == null){
Log.e(TAG, "Can not get status for component with id: " + componentId);
Log.e(TAG, "Component is null, skipping it");
continue;
}
Status state = component.getStatus(mContext);
Integer priority = components_priority_mapping.getOrDefault(componentId,
Integer.MIN_VALUE);
if(!state.isOk){
Log.d(TAG, "Got status: " + state.reason);
Log.d(TAG, "Component id: " + componentId);
Log.d(TAG, "Component prio: " + priority);
if(priority >= maxPriority){
status = state;
maxPriority = priority;
}
}
}
return status;
}
public String getStatusString(){
Status status = check();
if(status.isOk){
return "Connected";
} else {
return status.reason;
}
}
}

574
app/src/main/java/com/polar/nextcloudservices/SettingsActivity.java Normal file
View file

@ -0,0 +1,574 @@
package com.polar.nextcloudservices;
import java.util.Objects;
import java.util.Timer;
import java.util.TimerTask;
import android.Manifest;
import android.content.ComponentName;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.text.InputType;
import android.util.Log;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.Context;
import android.app.ActivityManager;
import android.view.MenuItem;
import android.widget.EditText;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.ActionBar;
import androidx.appcompat.app.AppCompatActivity;
import androidx.browser.customtabs.CustomTabsIntent;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.DialogFragment;
import androidx.fragment.app.FragmentManager;
import androidx.preference.EditTextPreference;
import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceManager;
import androidx.preference.Preference;
import com.nextcloud.android.sso.AccountImporter;
import com.nextcloud.android.sso.api.NextcloudAPI;
import com.nextcloud.android.sso.exceptions.AccountImportCancelledException;
import com.nextcloud.android.sso.exceptions.AndroidGetAccountsPermissionNotGranted;
import com.nextcloud.android.sso.exceptions.NextcloudFilesAppNotInstalledException;
import com.nextcloud.android.sso.model.SingleSignOnAccount;
import com.nextcloud.android.sso.ui.UiExceptionManager;
import com.polar.nextcloudservices.Services.NotificationServiceBinder;
import com.polar.nextcloudservices.Services.NotificationServiceController;
import com.polar.nextcloudservices.Services.Settings.ServiceSettingConfig;
import com.polar.nextcloudservices.Services.Settings.ServiceSettings;
import nl.invissvenska.numberpickerpreference.NumberDialogPreference;
import nl.invissvenska.numberpickerpreference.NumberPickerPreferenceDialogFragment;
class NotificationServiceConnection implements ServiceConnection {
private final String TAG = "SettingsActivity.NotificationServiceConnection";
private final SettingsActivity.SettingsFragment settings;
private NotificationServiceBinder mService;
public boolean isConnected = false;
public NotificationServiceConnection(SettingsActivity.SettingsFragment _settings) {
super();
settings = _settings;
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
if (service instanceof NotificationServiceBinder) {
mService = (NotificationServiceBinder) service;
settings.setStatus(((NotificationServiceBinder) service).getServiceStatus());
isConnected = true;
Log.i(TAG, "Connected to service");
} else {
Log.wtf(TAG, "Bad Binder type passed!");
throw new RuntimeException("Expected NotificationServiceBinder");
}
}
public void updateStatus(){
if(!isConnected){
Log.w(TAG, "Service has already disconnected");
settings.setStatus("Disconnected: service is not running");
} else {
settings.setStatus(mService.getServiceStatus());
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.w(TAG, "Service has disconnected.");
isConnected = false;
}
public void tellPreferencesChanged() {
Log.d(TAG, "Telling about preferences change to service");
if(mService == null){
Log.wtf(TAG, "Service is null. Have nobody to tell about settings update.");
return;
}
mService.onPreferencesChanged();
}
}
public class SettingsActivity extends AppCompatActivity {
private final String TAG = "SettingsActivity";
private final Handler mHandler = new Handler();
private Timer mTimer = null;
private PreferenceUpdateTimerTask mTask = null;
private NotificationServiceConnection mServiceConnection = null;
private NotificationServiceController mServiceController;
private ServiceSettings mServiceSettings;
private SettingsFragment mSettingsFragment;
private static final int NOTIFICATION_PERMISSION_CODE = 1;
//Exit from activity when back arrow is pressed
//https://stackoverflow.com/questions/34222591/navigate-back-from-settings-activity
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId() == android.R.id.home) {
super.onBackPressed();
return true;
}
return super.onOptionsItemSelected(item);
}
class PreferenceUpdateTimerTask extends TimerTask {
private final SettingsFragment mSettingsFragment;
public PreferenceUpdateTimerTask(SettingsFragment _settings) {
mSettingsFragment = _settings;
}
@Override
public void run() {
// run on another thread
mHandler.post(() -> {
if (isNotificationServiceRunning()) {
Log.d(TAG, "Service is running");
updateNotificationServiceStatus(mSettingsFragment);
} else {
(mSettingsFragment).setStatus("Disconnected: service is not running");
}
});
}
}
public void startNotificationService() {
if (!isNotificationServiceRunning() && mServiceSettings.isServiceEnabled() ) {
Log.d(TAG, "Service is not running: creating intent to start it");
mServiceController.startService(this);
}
}
private boolean isNotificationServiceRunning() {
Class<?> serviceClass = mServiceController.getServiceClass();
Log.d(TAG, "Checking whether service " + serviceClass + " is alive");
ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
if (serviceClass.getName().equals(service.service.getClassName())) {
return true;
}
}
return false;
}
private void updateNotificationServiceStatus(SettingsFragment settings) {
if (!isNotificationServiceRunning()) {
Log.e(TAG, "Service is not running!");
settings.setStatus("Disconnected: service is not running");
} else if(mServiceConnection == null && isNotificationServiceRunning()) {
Log.d(TAG, "Service is running but disconnected");
mServiceConnection = new NotificationServiceConnection(settings);
mServiceController.bindService(this, mServiceConnection);
} else if(mServiceConnection != null && isNotificationServiceRunning() && !mServiceConnection.isConnected){
Log.d(TAG, "Service is running but disconnected");
mServiceConnection = new NotificationServiceConnection(settings);
mServiceController.bindService(this, mServiceConnection);
} else {
mServiceConnection.updateStatus();
}
}
@Override
public void onDestroy(){
if (mTask != null){
mTask.cancel();
if(mTimer != null){
mTimer.purge();
}
}
super.onDestroy();
}
@Override
public void onStop() {
if (mTask != null){
mTask.cancel();
if(mTimer != null){
mTimer.purge();
}
}
super.onStop();
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.settings_activity);
if (savedInstanceState == null) {
Log.d(TAG,"savedInstanceState is null.");
SettingsFragment fragment = new SettingsFragment();
getSupportFragmentManager()
.beginTransaction()
.replace(R.id.settings, fragment)
.commit();
} else {
Log.d(TAG, "savedInstanceState is not null.");
}
ActionBar actionBar = getSupportActionBar();
if (actionBar != null) {
actionBar.setDisplayHomeAsUpEnabled(true);
}
mServiceSettings = new ServiceSettings(this);
mServiceController = new NotificationServiceController(mServiceSettings);
FragmentManager manager = getSupportFragmentManager();
mSettingsFragment = (SettingsFragment) manager.findFragmentById(R.id.settings);
requestNotificationPermission();
startNotificationService();
}
public void requestNotificationPermission() {
if(Build.VERSION.SDK_INT >= 33) {
if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED) {
Log.d(TAG, "Notification permission is granted.");
return;
}
Log.d(TAG, "Notification permission is not granted yet, so will request it now");
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.POST_NOTIFICATIONS}, NOTIFICATION_PERMISSION_CODE);
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == NOTIFICATION_PERMISSION_CODE) {
if (!(grantResults.length > 0) || grantResults[0] != PackageManager.PERMISSION_GRANTED){
Log.d(TAG, "User denied notification permission");
Toast.makeText(this, "Permission to send notifications is not granted. Use Settings app to grant it manually", Toast.LENGTH_LONG).show();
}
}
}
@Override
protected void onResume() {
super.onResume();
FragmentManager manager = getSupportFragmentManager();
mSettingsFragment = (SettingsFragment) manager.findFragmentById(R.id.settings);
if (mSettingsFragment == null) {
Log.wtf(TAG, "Programming error: settings fragment is not instance of SettingsFragment!");
throw new RuntimeException("Programming error: settings fragment is not instance of SettingsFragment!");
} else {
if (mTimer == null) {
mTimer = new Timer();
}
if (mTask != null){
mTask.cancel();
if(mTimer != null){
mTimer.purge();
}
}
Log.d(TAG, "Starting timer");
mTask = new PreferenceUpdateTimerTask((SettingsFragment) mSettingsFragment);
mTimer.scheduleAtFixedRate( mTask, 0, 5000);
}
}
private boolean needRestartService(String key){
return key == null;
}
public void onPreferencesChange(String key){
Log.d(TAG, "key = " + key);
if(Objects.equals(key, ServiceSettingConfig.USE_WEBSOCKET)){
if(!mServiceSettings.isServiceEnabled()){
return;
}
mServiceController.onServiceClassChange(this);
mServiceConnection = new NotificationServiceConnection(mSettingsFragment);
mServiceController.bindService(this, mServiceConnection);
} else if(needRestartService(key)) {
mServiceController.restartService(this);
mServiceConnection = new NotificationServiceConnection(mSettingsFragment);
mServiceController.bindService(this, mServiceConnection);
} else if(key.equals(ServiceSettingConfig.ENABLE_SERVICE)){
if(!isNotificationServiceRunning() && mServiceSettings.isServiceEnabled()){
mServiceController.startService(this);
mServiceConnection = new NotificationServiceConnection(mSettingsFragment);
mServiceController.bindService(this, mServiceConnection);
} else if(!mServiceSettings.isServiceEnabled()){
mServiceController.stopService(this);
mServiceConnection = null;
}
} else {
mServiceConnection.tellPreferencesChanged();
}
}
public static class SettingsFragment extends PreferenceFragmentCompat implements SharedPreferences.OnSharedPreferenceChangeListener{
private final String TAG = "SettingsActivity.SettingsFragment";
//private DialogFragment current_dialog_fragment = null;
private boolean getBoolPreference(String key, boolean fallback) {
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
return sharedPreferences.getBoolean(key, fallback);
}
private void notifyAccountChange(){
SettingsActivity activity = (SettingsActivity) getActivity();
if(activity == null){
Log.wtf(TAG, "Activity can not be null!");
throw new NullPointerException();
}
activity.onPreferencesChange(null);
}
private void enableSSO(@NonNull SingleSignOnAccount account){
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putBoolean("sso_enabled", true);
editor.putString("sso_name", account.name);
editor.putString("sso_server", account.url);
editor.putString("sso_type", account.type);
editor.putString("sso_token", account.token);
editor.putString("sso_userid", account.userId);
editor.apply();
setSSOPreferencesState();
notifyAccountChange();
}
private void disableSSO(){
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putBoolean("sso_enabled", false);
editor.apply();
setSSOPreferencesState();
notifyAccountChange();
}
private void openAccountChooser() {
try {
AccountImporter.pickNewAccount(this);
} catch (NextcloudFilesAppNotInstalledException | AndroidGetAccountsPermissionNotGranted e) {
UiExceptionManager.showDialogForException(getContext(), e);
}
}
private void setSSOPreferencesState(){
Preference login_sso = findPreference("login_sso");
if(login_sso == null){
Log.wtf(TAG, "login_sso preference is null!");
throw new NullPointerException();
}
if(getBoolPreference(ServiceSettingConfig.USE_WEBSOCKET, false)){
login_sso.setEnabled(false);
}
if(getBoolPreference("sso_enabled",false)){
findPreference("server").setEnabled(false);
findPreference("password").setEnabled(false);
findPreference("login").setEnabled(false);
findPreference("insecure_connection").setEnabled(false);
findPreference("use_websocket").setEnabled(false);
login_sso.setSummary("Stop using Nextcloud app for authentication");
login_sso.setTitle("Log out from Nexcloud");
login_sso.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
Log.d(TAG, "Disabling SSO");
disableSSO();
return true;
}
});
} else {
findPreference("server").setEnabled(true);
findPreference("password").setEnabled(true);
findPreference("login").setEnabled(true);
findPreference("insecure_connection").setEnabled(true);
findPreference("use_websocket").setEnabled(true);
login_sso.setSummary("Use on-device Nextcloud account");
login_sso.setTitle("Log in via Nextcloud app");
login_sso.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
Log.d(TAG, "Opening account chooser");
openAccountChooser();
return true;
}
});
}
}
@Override
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
setPreferencesFromResource(R.xml.root_preferences, rootKey);
Preference oss_licenses = (Preference) findPreference("credits");
oss_licenses.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
Intent intent = new Intent(getActivity(), CreditsActivity.class);
startActivity(intent);
return true;
}
});
Preference donate = (Preference) findPreference("donate");
donate.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
CustomTabsIntent browserIntent = new CustomTabsIntent.Builder()
.setUrlBarHidingEnabled(true)
.setShowTitle(false)
.setStartAnimations(getContext(), android.R.anim.fade_in, android.R.anim.fade_out)
.setExitAnimations(getContext(), android.R.anim.fade_in, android.R.anim.fade_out)
.setColorScheme(CustomTabsIntent.COLOR_SCHEME_SYSTEM)
.setShareState(CustomTabsIntent.SHARE_STATE_OFF)
.build();
browserIntent.launchUrl(getContext(), Uri.parse("https://liberapay.com/Andrewerr/donate"));
Toast.makeText(getContext(), R.string.donation_thank_you, Toast.LENGTH_SHORT).show();
return true;
}
});
/*
Preference login_sso = (Preference) findPreference("login_sso");
login_sso.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
Log.d(TAG, "Opening account chooser");
openAccountChooser();
return true;
}
});
*/
EditTextPreference passwordPreference = findPreference("password");
if (passwordPreference != null) {
passwordPreference.setOnBindEditTextListener(
new EditTextPreference.OnBindEditTextListener() {
@Override
public void onBindEditText(@NonNull EditText editText) {
editText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
}
});
}
setSSOPreferencesState();
}
public void setStatus(String _status) {
EditTextPreference status = (EditTextPreference) findPreference("status");
if (status == null) {
Log.wtf(TAG, "Unexpected null result of findPreference");
throw new RuntimeException("Expected EditTextPreference, but got null!");
} else {
status.setSummary(_status);
}
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
try {
AccountImporter.onActivityResult(requestCode, resultCode, data, this, new AccountImporter.IAccountAccessGranted() {
@Override
public void accountAccessGranted(SingleSignOnAccount singleSignOnAccount) {
enableSSO(singleSignOnAccount);
Log.i(TAG, "Succesfully imported account");
}
NextcloudAPI.ApiConnectedListener callback = new NextcloudAPI.ApiConnectedListener() {
@Override
public void onConnected() {
// ignore this one… see 5)
}
@Override
public void onError(Exception ex) {
ex.printStackTrace();
Toast.makeText(getContext(), ex.getLocalizedMessage(), Toast.LENGTH_LONG).show();
}
};
});
} catch (AccountImportCancelledException e) {
e.printStackTrace();
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
Log.d(TAG, "Succesfully got Nextcloud permissions");
AccountImporter.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onDisplayPreferenceDialog(Preference preference) {
Log.d(TAG, "Displaying preference dialog.");
if (preference instanceof NumberDialogPreference) {
NumberDialogPreference dialogPreference = (NumberDialogPreference) preference;
DialogFragment dialogFragment = NumberPickerPreferenceDialogFragment
.newInstance(
dialogPreference.getKey(),
dialogPreference.getMinValue(),
dialogPreference.getMaxValue(),
dialogPreference.getStepValue(),
dialogPreference.getUnitText()
);
dialogFragment.setTargetFragment(this, 0);
dialogFragment.show(getParentFragmentManager(), TAG + ".NumberPicker");
Log.d(TAG, "Showing dialog fragment.");
//current_dialog_fragment = dialogFragment;
} else {
super.onDisplayPreferenceDialog(preference);
}
}
@Override
public void onPause() {
Objects.requireNonNull(getPreferenceManager().getSharedPreferences())
.unregisterOnSharedPreferenceChangeListener(this);
super.onPause();
Log.d(TAG, "onPause called");
/*if(current_dialog_fragment != null){
Log.d(TAG, "Fragment has dialog opened.");
current_dialog_fragment.onPause();
}*/
}
@Override
public void onResume() {
Objects.requireNonNull(getPreferenceManager().getSharedPreferences())
.registerOnSharedPreferenceChangeListener(this);
super.onResume();
Log.d(TAG, "onResume called");
}
private void onWebsocketStatusChanged(){
if(getBoolPreference(ServiceSettingConfig.USE_WEBSOCKET, false)) {
findPreference("login_sso").setEnabled(false);
} else {
findPreference("login_sso").setEnabled(true);
}
}
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
SettingsActivity activity = (SettingsActivity) getActivity();
if(activity == null){
Log.wtf(TAG, "Activity can not be null!");
throw new NullPointerException();
}
if(key.equals(ServiceSettingConfig.USE_WEBSOCKET)){
onWebsocketStatusChanged();
}
activity.onPreferencesChange(key);
}
}
}

87
app/src/main/java/com/polar/nextcloudservices/Utils/CommonUtil.java Normal file
View file

@ -0,0 +1,87 @@
package com.polar.nextcloudservices.Utils;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.pm.PackageManager;
import android.util.Log;
import androidx.annotation.NonNull;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class CommonUtil {
private static final String TAG = "Utils.CommonUtil";
/**
* @param packageName name of package which should be checked
* @param packageManager system package manager access object
* @return true if package is present on device, false otherwise
*/
public static boolean isPackageInstalled(String packageName, PackageManager packageManager) {
try {
packageManager.getPackageInfo(packageName, 0);
return true;
} catch (PackageManager.NameNotFoundException e) {
return false;
}
}
/**
* Clean-ups URL by removing domain and protocol if needed
* according to wikipedia a uniform resource locator is composed of the following elements:
* URI = scheme ":" ["//" authority] path ["?" query] ["#" fragment]
* authority = [userinfo "@"] host [":" port]
* Example: "https://cloud.example.com/path?query#fragment" -> "/path?query#fragment"
* @param target Target URL to remove everything in front of the path
* @return String cleaned-up from protocol and domain
*/
public static String cleanUpURLIfNeeded(String target){
try {
URI uri = new URI(target);
String result = uri.getPath();
if(uri.getQuery() != null) {
result = result + "?" + uri.getQuery();
}
if(uri.getFragment() != null) {
result = result + "#" + uri.getFragment();
}
return result;
} catch (URISyntaxException e) {
Log.e(TAG, "error cleaning up target link.");
e.printStackTrace();
return null;
}
}
public static <T> boolean isInArray(T obj, T[] array){
return Arrays.asList(array).contains(obj);
}
public static void safeSleep(long millis){
try {
Thread.sleep(millis);
} catch (InterruptedException e){
Log.e(TAG, "Interrupted while sleeping " + millis + "ms");
}
}
public static String cleanUpURLParams(@NonNull String chatroom){
String[] splits = chatroom.split("#");
if(splits.length == 0){
return null;
} else {
return splits[0];
}
}
public static long getTimestamp(){
return System.currentTimeMillis();
}
}