diff --git a/src/org/kde/kdeconnect/Plugins/SharePlugin/CompositeReceiveFileRunnable.java b/src/org/kde/kdeconnect/Plugins/SharePlugin/CompositeReceiveFileRunnable.java new file mode 100644 index 00000000..0e1a4960 --- /dev/null +++ b/src/org/kde/kdeconnect/Plugins/SharePlugin/CompositeReceiveFileRunnable.java @@ -0,0 +1,307 @@ +/* + * Copyright 2018 Erik Duisters + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License or (at your option) version 3 or any later version + * accepted by the membership of KDE e.V. (or its successor approved + * by the membership of KDE e.V.), which shall act as a proxy + * defined in Section 14 of version 3 of the license. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.kde.kdeconnect.Plugins.SharePlugin; + +import android.app.DownloadManager; +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.Build; +import android.os.Handler; +import android.os.Looper; +import android.util.Log; + +import org.kde.kdeconnect.Device; +import org.kde.kdeconnect.Helpers.FilesHelper; +import org.kde.kdeconnect.Helpers.MediaStoreHelper; +import org.kde.kdeconnect.NetworkPacket; +import org.kde.kdeconnect_tp.R; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.List; + +import androidx.core.content.FileProvider; +import androidx.documentfile.provider.DocumentFile; + +public class CompositeReceiveFileRunnable implements Runnable { + interface CallBack { + void onSuccess(CompositeReceiveFileRunnable runnable); + void onError(CompositeReceiveFileRunnable runnable, Throwable error); + } + + private final Device device; + private final ShareNotification shareNotification; + private NetworkPacket currentNetworkPacket; + private String currentFileName; + private int currentFileNum; + private long totalReceived; + private long lastProgressTimeMillis; + private long prevProgressPercentage; + + private final CallBack callBack; + private final Handler handler; + + private final Object lock; //Use to protect concurrent access to the variables below + private final List networkPacketList; + private int totalNumFiles; + private long totalPayloadSize; + + CompositeReceiveFileRunnable(Device device, CallBack callBack) { + this.device = device; + this.callBack = callBack; + + lock = new Object(); + networkPacketList = new ArrayList<>(); + shareNotification = new ShareNotification(device); + currentFileNum = 0; + totalNumFiles = 0; + totalPayloadSize = 0; + totalReceived = 0; + lastProgressTimeMillis = 0; + prevProgressPercentage = 0; + handler = new Handler(Looper.getMainLooper()); + } + + void addNetworkPacket(NetworkPacket networkPacket) { + if (!networkPacketList.contains(networkPacket)) { + synchronized (lock) { + networkPacketList.add(networkPacket); + + totalNumFiles = networkPacket.getInt(SharePlugin.KEY_NUMBER_OF_FILES, 1); + totalPayloadSize = networkPacket.getLong(SharePlugin.KEY_TOTAL_PAYLOAD_SIZE); + + shareNotification.setTitle(device.getContext().getResources() + .getQuantityString(R.plurals.incoming_file_title, totalNumFiles, totalNumFiles, device.getName())); + } + } + } + + @Override + public void run() { + boolean done; + OutputStream outputStream = null; + + synchronized (lock) { + done = networkPacketList.isEmpty(); + } + + try { + DocumentFile fileDocument = null; + + while (!done) { + synchronized (lock) { + currentNetworkPacket = networkPacketList.get(0); + } + currentFileName = currentNetworkPacket.getString("filename", Long.toString(System.currentTimeMillis())); + currentFileNum++; + + setProgress((int)prevProgressPercentage); + + fileDocument = getDocumentFileFor(currentFileName, currentNetworkPacket.getBoolean("open")); + + if (currentNetworkPacket.hasPayload()) { + outputStream = new BufferedOutputStream(device.getContext().getContentResolver().openOutputStream(fileDocument.getUri())); + InputStream inputStream = currentNetworkPacket.getPayload().getInputStream(); + + long received = receiveFile(inputStream, outputStream); + + currentNetworkPacket.getPayload().close(); + + if ( received != currentNetworkPacket.getPayloadSize()) { + fileDocument.delete(); + throw new RuntimeException("Failed to receive: " + currentFileName + " received:" + received + " bytes, expected: " + currentNetworkPacket.getPayloadSize() + " bytes"); + } else { + publishFile(fileDocument, received); + } + } else { + setProgress(100); + publishFile(fileDocument, 0); + } + + boolean listIsEmpty; + + synchronized (lock) { + networkPacketList.remove(0); + listIsEmpty = networkPacketList.isEmpty(); + } + + if (listIsEmpty) { + try { + Thread.sleep(250); + } catch (InterruptedException ignored) {} + + synchronized (lock) { + if (currentFileNum < totalNumFiles && networkPacketList.isEmpty()) { + throw new RuntimeException("Failed to receive " + (totalNumFiles - currentFileNum + 1) + " files"); + } + } + } + + synchronized (lock) { + done = networkPacketList.isEmpty(); + } + } + + int numFiles; + synchronized (lock) { + numFiles = totalNumFiles; + } + + if (numFiles == 1 && currentNetworkPacket.has("open")) { + shareNotification.cancel(); + openFile(fileDocument); + } else { + //Update the notification and allow to open the file from it + shareNotification.setFinished(device.getContext().getResources().getQuantityString(R.plurals.received_files_title, numFiles, device.getName(), numFiles)); + + if (totalNumFiles == 1 && fileDocument != null) { + shareNotification.setURI(fileDocument.getUri(), fileDocument.getType(), fileDocument.getName()); + } + + shareNotification.show(); + } + handler.post(() -> callBack.onSuccess(this)); + } catch (Exception e) { + int failedFiles; + synchronized (lock) { + failedFiles = (totalNumFiles - currentFileNum + 1); + } + shareNotification.setFinished(device.getContext().getResources().getQuantityString(R.plurals.received_files_fail_title, failedFiles, device.getName(), failedFiles, totalNumFiles)); + shareNotification.show(); + handler.post(() -> callBack.onError(this, e)); + } finally { + closeAllInputStreams(); + networkPacketList.clear(); + if (outputStream != null) { + try { + outputStream.close(); + } catch (IOException ignored) {} + } + } + } + + private DocumentFile getDocumentFileFor(final String filename, final boolean open) throws RuntimeException { + final DocumentFile destinationFolderDocument; + + String filenameToUse = filename; + + //We need to check for already existing files only when storing in the default path. + //User-defined paths use the new Storage Access Framework that already handles this. + //If the file should be opened immediately store it in the standard location to avoid the FileProvider trouble (See ShareNotification::setURI) + if (open || !ShareSettingsFragment.isCustomDestinationEnabled(device.getContext())) { + final String defaultPath = ShareSettingsFragment.getDefaultDestinationDirectory().getAbsolutePath(); + filenameToUse = FilesHelper.findNonExistingNameForNewFile(defaultPath, filenameToUse); + destinationFolderDocument = DocumentFile.fromFile(new File(defaultPath)); + } else { + destinationFolderDocument = ShareSettingsFragment.getDestinationDirectory(device.getContext()); + } + String displayName = FilesHelper.getFileNameWithoutExt(filenameToUse); + String mimeType = FilesHelper.getMimeTypeFromFile(filenameToUse); + + if ("*/*".equals(mimeType)) { + displayName = filenameToUse; + } + + DocumentFile fileDocument = destinationFolderDocument.createFile(mimeType, displayName); + + if (fileDocument == null) { + throw new RuntimeException(device.getContext().getString(R.string.cannot_create_file, filenameToUse)); + } + + return fileDocument; + } + + private long receiveFile(InputStream input, OutputStream output) throws IOException { + byte data[] = new byte[4096]; + int count; + long received = 0; + + while ((count = input.read(data)) >= 0) { + received += count; + totalReceived += count; + + output.write(data, 0, count); + + long progressPercentage; + synchronized (lock) { + progressPercentage = (totalReceived * 100 / totalPayloadSize); + } + long curTimeMillis = System.currentTimeMillis(); + + if (progressPercentage != prevProgressPercentage && + (progressPercentage == 100 || curTimeMillis - lastProgressTimeMillis >= 500)) { + prevProgressPercentage = progressPercentage; + lastProgressTimeMillis = curTimeMillis; + setProgress((int)progressPercentage); + } + } + + output.flush(); + + return received; + } + + private void closeAllInputStreams() { + for (NetworkPacket np : networkPacketList) { + np.getPayload().close(); + } + } + + private void setProgress(int progress) { + synchronized (lock) { + shareNotification.setProgress(progress, device.getContext().getResources() + .getQuantityString(R.plurals.incoming_files_text, totalNumFiles, currentFileName, currentFileNum, totalNumFiles)); + } + shareNotification.show(); + } + + private void publishFile(DocumentFile fileDocument, long size) { + if (!ShareSettingsFragment.isCustomDestinationEnabled(device.getContext())) { + Log.i("SharePlugin", "Adding to downloads"); + DownloadManager manager = (DownloadManager) device.getContext().getSystemService(Context.DOWNLOAD_SERVICE); + manager.addCompletedDownload(fileDocument.getUri().getLastPathSegment(), device.getName(), true, fileDocument.getType(), fileDocument.getUri().getPath(), size, false); + } else { + //Make sure it is added to the Android Gallery anyway + Log.i("SharePlugin", "Adding to gallery"); + MediaStoreHelper.indexFile(device.getContext(), fileDocument.getUri()); + } + } + + private void openFile(DocumentFile fileDocument) { + Intent intent = new Intent(Intent.ACTION_VIEW); + if (Build.VERSION.SDK_INT >= 24) { + //Nougat and later require "content://" uris instead of "file://" uris + File file = new File(fileDocument.getUri().getPath()); + Uri contentUri = FileProvider.getUriForFile(device.getContext(), "org.kde.kdeconnect_tp.fileprovider", file); + intent.setDataAndType(contentUri, fileDocument.getType()); + intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); + } else { + intent.setDataAndType(fileDocument.getUri(), fileDocument.getType()); + } + + device.getContext().startActivity(intent); + } +} diff --git a/src/org/kde/kdeconnect/Plugins/SharePlugin/ReceiveFileRunnable.java b/src/org/kde/kdeconnect/Plugins/SharePlugin/ReceiveFileRunnable.java deleted file mode 100644 index 32301969..00000000 --- a/src/org/kde/kdeconnect/Plugins/SharePlugin/ReceiveFileRunnable.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright 2018 Erik Duisters - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 of - * the License or (at your option) version 3 or any later version - * accepted by the membership of KDE e.V. (or its successor approved - * by the membership of KDE e.V.), which shall act as a proxy - * defined in Section 14 of version 3 of the license. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -package org.kde.kdeconnect.Plugins.SharePlugin; - -import android.os.Handler; -import android.os.Looper; - -import java.io.IOException; -import java.io.InputStream; - -public class ReceiveFileRunnable implements Runnable { - interface CallBack { - void onProgress(ShareInfo info, int progress); - void onSuccess(ShareInfo info); - void onError(ShareInfo info, Throwable error); - } - - private final ShareInfo info; - private final CallBack callBack; - private final Handler handler; - - ReceiveFileRunnable(ShareInfo info, CallBack callBack) { - this.info = info; - this.callBack = callBack; - this.handler = new Handler(Looper.getMainLooper()); - } - - @Override - public void run() { - try { - byte data[] = new byte[4096]; - long received = 0, prevProgressPercentage = 0; - int count; - - callBack.onProgress(info, 0); - - InputStream inputStream = info.payload.getInputStream(); - - while ((count = inputStream.read(data)) >= 0) { - received += count; - - if (received > info.fileSize) { - break; - } - - info.outputStream.write(data, 0, count); - if (info.fileSize > 0) { - long progressPercentage = (received * 100 / info.fileSize); - if (progressPercentage != prevProgressPercentage) { - prevProgressPercentage = progressPercentage; - handler.post(() -> callBack.onProgress(info, (int)progressPercentage)); - } - } - //else Log.e("SharePlugin", "Infinite loop? :D"); - } - - info.outputStream.flush(); - - if (received != info.fileSize) { - throw new RuntimeException("Received:" + received + " bytes, expected: " + info.fileSize + " bytes"); - } - - handler.post(() -> callBack.onSuccess(info)); - } catch (IOException e) { - handler.post(() -> callBack.onError(info, e)); - } finally { - info.payload.close(); - - try { - info.outputStream.close(); - } catch (IOException ignored) {} - } - } -} diff --git a/src/org/kde/kdeconnect/Plugins/SharePlugin/SharePlugin.java b/src/org/kde/kdeconnect/Plugins/SharePlugin/SharePlugin.java index 7938fa77..de7c2aaf 100644 --- a/src/org/kde/kdeconnect/Plugins/SharePlugin/SharePlugin.java +++ b/src/org/kde/kdeconnect/Plugins/SharePlugin/SharePlugin.java @@ -1,547 +1,420 @@ /* * Copyright 2014 Albert Vaca Cintora * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ package org.kde.kdeconnect.Plugins.SharePlugin; import android.Manifest; import android.app.Activity; -import android.app.DownloadManager; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.content.ClipboardManager; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.res.Resources; import android.database.Cursor; import android.graphics.drawable.Drawable; import android.net.Uri; -import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.provider.MediaStore; import android.util.Log; import android.widget.Toast; -import org.kde.kdeconnect.Helpers.FilesHelper; -import org.kde.kdeconnect.Helpers.MediaStoreHelper; import org.kde.kdeconnect.Helpers.NotificationHelper; import org.kde.kdeconnect.NetworkPacket; import org.kde.kdeconnect.Plugins.Plugin; import org.kde.kdeconnect.UserInterface.PluginSettingsFragment; import org.kde.kdeconnect_tp.R; -import java.io.BufferedOutputStream; import java.io.File; -import java.io.FileNotFoundException; import java.io.InputStream; import java.net.URL; import java.util.ArrayList; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import androidx.annotation.WorkerThread; import androidx.core.app.NotificationCompat; import androidx.core.content.ContextCompat; -import androidx.core.content.FileProvider; -import androidx.documentfile.provider.DocumentFile; - -public class SharePlugin extends Plugin implements ReceiveFileRunnable.CallBack { +public class SharePlugin extends Plugin { private final static String PACKET_TYPE_SHARE_REQUEST = "kdeconnect.share.request"; + final static String KEY_NUMBER_OF_FILES = "numberOfFiles"; + final static String KEY_TOTAL_PAYLOAD_SIZE = "totalPayloadSize"; + private final static boolean openUrlsDirectly = true; - private ShareNotification shareNotification; - private FinishReceivingRunnable finishReceivingRunnable; private ExecutorService executorService; - private ShareInfo currentShareInfo; - private Handler handler; + private final Handler handler; + CompositeReceiveFileRunnable receiveFileRunnable; + private final Callback receiveFileRunnableCallback; public SharePlugin() { - executorService = Executors.newSingleThreadExecutor(); + executorService = Executors.newFixedThreadPool(5); handler = new Handler(Looper.getMainLooper()); + receiveFileRunnableCallback = new Callback(); } @Override public boolean onCreate() { optionalPermissionExplanation = R.string.share_optional_permission_explanation; return true; } @Override public String getDisplayName() { return context.getResources().getString(R.string.pref_plugin_sharereceiver); } @Override public Drawable getIcon() { return ContextCompat.getDrawable(context, R.drawable.share_plugin_action); } @Override public String getDescription() { return context.getResources().getString(R.string.pref_plugin_sharereceiver_desc); } @Override public boolean hasMainActivity() { return true; } @Override public String getActionName() { return context.getString(R.string.send_files); } @Override public void startMainActivity(Activity parentActivity) { Intent intent = new Intent(parentActivity, SendFileActivity.class); intent.putExtra("deviceId", device.getDeviceId()); parentActivity.startActivity(intent); } @Override public boolean hasSettings() { return true; } @Override @WorkerThread public boolean onPacketReceived(NetworkPacket np) { try { if (np.has("filename")) { if (isPermissionGranted(Manifest.permission.WRITE_EXTERNAL_STORAGE)) { receiveFile(np); } else { Log.i("SharePlugin", "no Permission for Storage"); } } else if (np.has("text")) { Log.i("SharePlugin", "hasText"); receiveText(np); } else if (np.has("url")) { receiveUrl(np); } else { Log.e("SharePlugin", "Error: Nothing attached!"); } } catch (Exception e) { Log.e("SharePlugin", "Exception"); e.printStackTrace(); } return true; } private void receiveUrl(NetworkPacket np) { String url = np.getString("url"); Log.i("SharePlugin", "hasUrl: " + url); Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)); browserIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); if (openUrlsDirectly) { context.startActivity(browserIntent); } else { Resources res = context.getResources(); PendingIntent resultPendingIntent = PendingIntent.getActivity( context, 0, browserIntent, PendingIntent.FLAG_UPDATE_CURRENT ); NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE); Notification noti = new NotificationCompat.Builder(context, NotificationHelper.Channels.DEFAULT) .setContentTitle(res.getString(R.string.received_url_title, device.getName())) .setContentText(res.getString(R.string.received_url_text, url)) .setContentIntent(resultPendingIntent) .setTicker(res.getString(R.string.received_url_title, device.getName())) .setSmallIcon(R.drawable.ic_notification) .setAutoCancel(true) .setDefaults(Notification.DEFAULT_ALL) .build(); NotificationHelper.notifyCompat(notificationManager, (int) System.currentTimeMillis(), noti); } } private void receiveText(NetworkPacket np) { String text = np.getString("text"); ClipboardManager cm = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE); cm.setText(text); handler.post(() -> Toast.makeText(context, R.string.shareplugin_text_saved, Toast.LENGTH_LONG).show()); } @WorkerThread private void receiveFile(NetworkPacket np) { - if (finishReceivingRunnable != null) { - Log.i("SharePlugin", "receiveFile: canceling finishReceivingRunnable"); - handler.removeCallbacks(finishReceivingRunnable); - finishReceivingRunnable = null; - } + CompositeReceiveFileRunnable runnable; - ShareInfo info = new ShareInfo(); - info.currentFileNumber = currentShareInfo == null ? 1 : currentShareInfo.currentFileNumber + 1; - info.payload = np.getPayload(); - info.fileSize = np.getPayloadSize(); - info.fileName = np.getString("filename", Long.toString(System.currentTimeMillis())); - info.shouldOpen = np.getBoolean("open"); - info.setNumberOfFiles(np.getInt("numberOfFiles", 1)); - info.setTotalTransferSize(np.getLong("totalPayloadSize", 1)); - - if (currentShareInfo == null) { - currentShareInfo = info; - } else { - synchronized (currentShareInfo) { - currentShareInfo.setNumberOfFiles(info.numberOfFiles()); - currentShareInfo.setTotalTransferSize(info.totalTransferSize()); - } - } + boolean hasNumberOfFiles = np.has(KEY_NUMBER_OF_FILES); + boolean hasOpen = np.has("open"); - String filename = info.fileName; - final DocumentFile destinationFolderDocument; - - //We need to check for already existing files only when storing in the default path. - //User-defined paths use the new Storage Access Framework that already handles this. - //If the file should be opened immediately store it in the standard location to avoid the FileProvider trouble (See ShareNotification::setURI) - if (np.getBoolean("open") || !ShareSettingsFragment.isCustomDestinationEnabled(context)) { - final String defaultPath = ShareSettingsFragment.getDefaultDestinationDirectory().getAbsolutePath(); - filename = FilesHelper.findNonExistingNameForNewFile(defaultPath, filename); - destinationFolderDocument = DocumentFile.fromFile(new File(defaultPath)); + if (hasNumberOfFiles && !hasOpen && receiveFileRunnable != null) { + runnable = receiveFileRunnable; } else { - destinationFolderDocument = ShareSettingsFragment.getDestinationDirectory(context); - } - String displayName = FilesHelper.getFileNameWithoutExt(filename); - String mimeType = FilesHelper.getMimeTypeFromFile(filename); - - if ("*/*".equals(mimeType)) { - displayName = filename; - } - - info.fileDocument = destinationFolderDocument.createFile(mimeType, displayName); - assert info.fileDocument != null; - - if (shareNotification == null) { - shareNotification = new ShareNotification(device); + runnable = new CompositeReceiveFileRunnable(device, receiveFileRunnableCallback); } - if (info.fileDocument == null) { - onError(info, new RuntimeException(context.getString(R.string.cannot_create_file, filename))); - return; + if (!hasNumberOfFiles) { + np.set(KEY_NUMBER_OF_FILES, 1); + np.set(KEY_TOTAL_PAYLOAD_SIZE, np.getPayloadSize()); } - shareNotification.setTitle(context.getResources().getQuantityString(R.plurals.incoming_file_title, info.numberOfFiles(), info.numberOfFiles(), device.getName())); - shareNotification.show(); + runnable.addNetworkPacket(np); - if (np.hasPayload()) { - try { - info.outputStream = new BufferedOutputStream(context.getContentResolver().openOutputStream(info.fileDocument.getUri())); - } catch (FileNotFoundException e) { - e.printStackTrace(); - return; + if (runnable != receiveFileRunnable) { + if (hasNumberOfFiles && !hasOpen) { + receiveFileRunnable = runnable; } - - ReceiveFileRunnable runnable = new ReceiveFileRunnable(info, this); executorService.execute(runnable); - } else { - onProgress(info, 100); - onSuccess(info); } } @Override public PluginSettingsFragment getSettingsFragment() { return ShareSettingsFragment.newInstance(getPluginKey()); } void queuedSendUriList(final ArrayList uriList) { //Read all the data early, as we only have permissions to do it while the activity is alive final ArrayList toSend = new ArrayList<>(); for (Uri uri : uriList) { NetworkPacket np = uriToNetworkPacket(context, uri); if (np != null) { toSend.add(np); } } //Callback that shows a progress notification final NotificationUpdateCallback notificationUpdateCallback = new NotificationUpdateCallback(context, device, toSend); //Do the sending in background new Thread(() -> { //Actually send the files try { for (NetworkPacket np : toSend) { boolean success = device.sendPacketBlocking(np, notificationUpdateCallback); if (!success) { Log.e("SharePlugin", "Error sending files"); return; } } } catch (Exception e) { e.printStackTrace(); } }).start(); } //Create the network package from the URI private static NetworkPacket uriToNetworkPacket(final Context context, final Uri uri) { try { ContentResolver cr = context.getContentResolver(); InputStream inputStream = cr.openInputStream(uri); NetworkPacket np = new NetworkPacket(PACKET_TYPE_SHARE_REQUEST); long size = -1; if (uri.getScheme().equals("file")) { // file:// is a non media uri, so we cannot query the ContentProvider np.set("filename", uri.getLastPathSegment()); try { size = new File(uri.getPath()).length(); } catch (Exception e) { Log.e("SendFileActivity", "Could not obtain file size"); e.printStackTrace(); } } else { // Probably a content:// uri, so we query the Media content provider Cursor cursor = null; try { String[] proj = {MediaStore.MediaColumns.DATA, MediaStore.MediaColumns.SIZE, MediaStore.MediaColumns.DISPLAY_NAME}; cursor = cr.query(uri, proj, null, null, null); int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA); cursor.moveToFirst(); String path = cursor.getString(column_index); np.set("filename", Uri.parse(path).getLastPathSegment()); size = new File(path).length(); } catch (Exception unused) { Log.w("SendFileActivity", "Could not resolve media to a file, trying to get info as media"); try { int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DISPLAY_NAME); cursor.moveToFirst(); String name = cursor.getString(column_index); np.set("filename", name); } catch (Exception e) { e.printStackTrace(); Log.e("SendFileActivity", "Could not obtain file name"); } try { int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.SIZE); cursor.moveToFirst(); //For some reason this size can differ from the actual file size! size = cursor.getInt(column_index); } catch (Exception e) { Log.e("SendFileActivity", "Could not obtain file size"); e.printStackTrace(); } } finally { try { cursor.close(); } catch (Exception ignored) { } } } np.setPayload(new NetworkPacket.Payload(inputStream, size)); return np; } catch (Exception e) { Log.e("SendFileActivity", "Exception sending files"); e.printStackTrace(); return null; } } public void share(Intent intent) { Bundle extras = intent.getExtras(); if (extras != null) { if (extras.containsKey(Intent.EXTRA_STREAM)) { try { ArrayList uriList; if (!Intent.ACTION_SEND.equals(intent.getAction())) { uriList = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM); } else { Uri uri = extras.getParcelable(Intent.EXTRA_STREAM); uriList = new ArrayList<>(); uriList.add(uri); } queuedSendUriList(uriList); } catch (Exception e) { Log.e("ShareActivity", "Exception"); e.printStackTrace(); } } else if (extras.containsKey(Intent.EXTRA_TEXT)) { String text = extras.getString(Intent.EXTRA_TEXT); String subject = extras.getString(Intent.EXTRA_SUBJECT); //Hack: Detect shared youtube videos, so we can open them in the browser instead of as text if (subject != null && subject.endsWith("YouTube")) { int index = text.indexOf(": http://youtu.be/"); if (index > 0) { text = text.substring(index + 2); //Skip ": " } } boolean isUrl; try { new URL(text); isUrl = true; } catch (Exception e) { isUrl = false; } NetworkPacket np = new NetworkPacket(SharePlugin.PACKET_TYPE_SHARE_REQUEST); if (isUrl) { np.set("url", text); } else { np.set("text", text); } device.sendPacket(np); } } } @Override public String[] getSupportedPacketTypes() { return new String[]{PACKET_TYPE_SHARE_REQUEST}; } @Override public String[] getOutgoingPacketTypes() { return new String[]{PACKET_TYPE_SHARE_REQUEST}; } @Override public String[] getOptionalPermissions() { return new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}; } - @Override - public void onProgress(ShareInfo info, int progress) { - if (progress == 0 && currentShareInfo != info) { - currentShareInfo = info; - } - - shareNotification.setProgress(progress, context.getResources().getQuantityString(R.plurals.incoming_files_text, info.numberOfFiles(), info.fileName, info.currentFileNumber, info.numberOfFiles())); - shareNotification.show(); - } - - @Override - public void onSuccess(ShareInfo info) { - Log.i("SharePlugin", "onSuccess() - Transfer finished for file: " + info.fileDocument.getUri().getPath()); - - if (info.shouldOpen) { - shareNotification.cancel(); - - Intent intent = new Intent(Intent.ACTION_VIEW); - if (Build.VERSION.SDK_INT >= 24) { - //Nougat and later require "content://" uris instead of "file://" uris - File file = new File(info.fileDocument.getUri().getPath()); - Uri contentUri = FileProvider.getUriForFile(device.getContext(), "org.kde.kdeconnect_tp.fileprovider", file); - intent.setDataAndType(contentUri, info.fileDocument.getType()); - intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); - } else { - intent.setDataAndType(info.fileDocument.getUri(), info.fileDocument.getType()); - } - - context.startActivity(intent); - } else { - if (!ShareSettingsFragment.isCustomDestinationEnabled(context)) { - Log.i("SharePlugin", "Adding to downloads"); - DownloadManager manager = (DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE); - manager.addCompletedDownload(info.fileDocument.getUri().getLastPathSegment(), device.getName(), true, info.fileDocument.getType(), info.fileDocument.getUri().getPath(), info.fileSize, false); - } else { - //Make sure it is added to the Android Gallery anyway - MediaStoreHelper.indexFile(context, info.fileDocument.getUri()); - } - - if (info.numberOfFiles() == 1 || info.currentFileNumber == info.numberOfFiles()) { - finishReceivingRunnable = new FinishReceivingRunnable(info); - Log.i("SharePlugin", "onSuccess() - scheduling finishReceivingRunnable"); - handler.postDelayed(finishReceivingRunnable, 1000); + private class Callback implements CompositeReceiveFileRunnable.CallBack { + @Override + public void onSuccess(CompositeReceiveFileRunnable runnable) { + if (runnable == receiveFileRunnable) { + receiveFileRunnable = null; } } - } - - @Override - public void onError(ShareInfo info, Throwable error) { - Log.e("SharePlugin", "onError: " + error.getMessage()); - - info.fileDocument.delete(); - - //TODO: Show error in notification - int failedFiles = info.numberOfFiles() - (info.currentFileNumber - 1); - shareNotification.setFinished(context.getResources().getQuantityString(R.plurals.received_files_fail_title, failedFiles, device.getName(), failedFiles, info.numberOfFiles())); - shareNotification.show(); - shareNotification = null; - currentShareInfo = null; - } - - private class FinishReceivingRunnable implements Runnable { - private final ShareInfo info; - - private FinishReceivingRunnable(ShareInfo info) { - this.info = info; - } @Override - public void run() { - Log.i("SharePlugin", "FinishReceivingRunnable: Finishing up"); - - if (shareNotification != null) { - //Update the notification and allow to open the file from it - shareNotification.setFinished(context.getResources().getQuantityString(R.plurals.received_files_title, info.numberOfFiles(), device.getName(), info.numberOfFiles())); - - if (info.numberOfFiles() == 1) { - shareNotification.setURI(info.fileDocument.getUri(), info.fileDocument.getType(), info.fileName); - } - - shareNotification.show(); - shareNotification = null; + public void onError(CompositeReceiveFileRunnable runnable, Throwable error) { + Log.e("SharePlugin", "onError() - " + error.getMessage()); + if (runnable == receiveFileRunnable) { + receiveFileRunnable = null; } - - finishReceivingRunnable = null; - currentShareInfo = null; } } }