@tbvjaos510/react-native-paste-input 0.9.0

package/android/src/main/java/com/mattermost/pasteinputtext/PasteInputFileFromUrl.kt

@@ -0,0 +1,50 @@
+package com.mattermost.pasteinputtext
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.textinput.ReactEditText
+import java.io.IOException
+import java.net.URL
+
+class PasteInputFileFromUrl(target: ReactEditText, uri: String, surfaceId: Int, eventDispatcher: EventDispatcher?): Runnable {
+  private val mTarget = target
+  private val mUri = uri
+  private val mEventDispatcher = eventDispatcher
+  private val mSurfaceId = surfaceId
+
+  override fun run() {
+    var files: WritableArray? = null
+    var error: WritableMap? = null
+
+    try {
+      val url = URL(mUri)
+      val conn = url.openConnection()
+      val mimeType = conn.getHeaderField("Content-Type")
+      val fileSize = java.lang.Long.parseLong(conn.getHeaderField("Content-Length"))
+      val contentDisposition = conn.getHeaderField("Content-Disposition")
+      val startIndex = contentDisposition.indexOf("filename=\"") + 10
+      val endIndex = contentDisposition.length - 1
+      val fileName = contentDisposition.substring(startIndex, endIndex)
+      val file = Arguments.createMap()
+
+      file.putString("type", mimeType)
+      file.putDouble("fileSize", fileSize.toDouble())
+      file.putString("fileName", fileName)
+      file.putString("uri", mUri)
+
+      files = Arguments.createArray()
+      files.pushMap(file)
+    } catch (e: IOException) {
+      error = Arguments.createMap()
+      error.putString("message", e.localizedMessage)
+    }
+
+    val event = Arguments.createMap()
+    event.putArray("data", files)
+    event.putMap("error", error)
+
+    mEventDispatcher?.dispatchEvent(PasteTextInputPasteEvent(mSurfaceId, mTarget.id, event))
+  }
+}

package/android/src/main/java/com/mattermost/pasteinputtext/PasteInputListener.kt

@@ -0,0 +1,84 @@
+package com.mattermost.pasteinputtext
+
+import android.content.ClipboardManager
+import android.content.Context
+import android.net.Uri
+import android.util.Patterns
+import android.webkit.MimeTypeMap
+import android.webkit.URLUtil
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.EventDispatcher
+import java.io.FileNotFoundException
+
+class PasteInputListener(editText: PasteInputEditText, surfaceId: Int) : IPasteInputListener {
+  private val mEditText = editText
+  private val mSurfaceId = surfaceId
+
+  override fun onPaste(itemUri: Uri, eventDispatcher: EventDispatcher?) {
+    val reactContext = mEditText.context as ReactContext
+    reactContext.contentResolver.getType(itemUri) ?: return
+
+    var uriString: String = itemUri.toString()
+    val mimeType: String
+    val fileSize: Long
+    var files: WritableArray? = null
+    var error: WritableMap? = null
+
+    // Special handle for Google docs
+    if (uriString == "content://com.google.android.apps.docs.editors.kix.editors.clipboard") {
+      val clipboardManager = reactContext.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+      val clipData = clipboardManager.primaryClip ?: return
+      val item = clipData.getItemAt(0) ?: return
+      val htmlText = item.htmlText
+
+      // Find uri from html
+      val matcher = Patterns.WEB_URL.matcher(htmlText)
+      if (matcher.find()) {
+        uriString = htmlText.substring(matcher.start(1), matcher.end())
+      }
+    } else if (uriString.startsWith("http")) {
+      val pastImageFromUrlThread = Thread(PasteInputFileFromUrl(
+        mEditText,
+        uriString,
+        mSurfaceId,
+        eventDispatcher
+      ))
+      pastImageFromUrlThread.start()
+      return
+    } else {
+      uriString = RealPathUtil.getRealPathFromURI(reactContext, itemUri) ?: return
+    }
+
+    val extension: String = MimeTypeMap.getFileExtensionFromUrl(uriString) ?: return
+    mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension) ?: return
+    val fileName: String = URLUtil.guessFileName(uriString, null, mimeType)
+
+    try {
+      val contentResolver = reactContext.contentResolver
+      val assetFileDescriptor = contentResolver.openAssetFileDescriptor(itemUri, "r") ?: return
+      val file = Arguments.createMap()
+
+      files = Arguments.createArray()
+      fileSize = assetFileDescriptor.length
+      file.putString("type", mimeType)
+      file.putDouble("fileSize", fileSize.toDouble())
+      file.putString("fileName", fileName)
+      file.putString("uri", "file://$uriString")
+
+      files.pushMap(file)
+      assetFileDescriptor.close()
+    } catch (e: FileNotFoundException) {
+      error = Arguments.createMap()
+      error.putString("message", e.localizedMessage)
+    }
+
+    val event = Arguments.createMap()
+    event.putArray("data", files)
+    event.putMap("error", error)
+
+    eventDispatcher?.dispatchEvent(PasteTextInputPasteEvent(mSurfaceId, mEditText.id, event))
+  }
+}

package/android/src/main/java/com/mattermost/pasteinputtext/PasteTextInputManager.kt

@@ -0,0 +1,72 @@
+package com.mattermost.pasteinputtext
+
+import android.text.InputType
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.textinput.ReactEditText
+import com.facebook.react.views.textinput.ReactTextInputManager
+
+@ReactModule(name = "PasteTextInput")
+class PasteTextInputManager(context: ReactApplicationContext) : ReactTextInputManager() {
+  private var disableCopyPaste: Boolean = false
+  private val mContext = context
+
+  override fun getName(): String = NAME
+
+  @ReactProp(name = "disableCopyPaste", defaultBoolean = false)
+  fun setDisableCopyPaste(editText: PasteInputEditText, disabled: Boolean) {
+    disableCopyPaste = disabled
+    val eventDispatcher = getEventDispatcher(mContext, editText)
+    editText.customInsertionActionModeCallback = PasteInputActionCallback(editText, disabled, eventDispatcher)
+    editText.customSelectionActionModeCallback = PasteInputActionCallback(editText, disabled, eventDispatcher)
+    editText.setDisableCopyPaste(disabled)
+  }
+
+  private fun getEventDispatcher(reactContext: ReactContext, editText: ReactEditText): EventDispatcher? {
+    return UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
+  }
+
+  override fun createViewInstance(context: ThemedReactContext): PasteInputEditText {
+    val editText = PasteInputEditText(context)
+    val inputType = editText.inputType
+
+    editText.inputType = inputType and (InputType.TYPE_TEXT_FLAG_MULTI_LINE.inv())
+    editText.returnKeyType = "done"
+    val eventDispatcher = getEventDispatcher(mContext, editText)
+    editText.customInsertionActionModeCallback = PasteInputActionCallback(editText, disableCopyPaste, eventDispatcher)
+    editText.customSelectionActionModeCallback = PasteInputActionCallback(editText, disableCopyPaste, eventDispatcher)
+
+    return editText
+  }
+
+  override fun addEventEmitters(reactContext: ThemedReactContext, editText: ReactEditText) {
+    super.addEventEmitters(reactContext, editText)
+
+    val pasteInputEditText = editText as PasteInputEditText
+    val eventDispatcher = getEventDispatcher(reactContext, editText)
+    pasteInputEditText.setOnPasteListener(PasteInputListener(pasteInputEditText, reactContext.surfaceId), eventDispatcher)
+  }
+
+  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+    val map = super.getExportedCustomBubblingEventTypeConstants()?.toMutableMap()
+      ?: return mutableMapOf()
+
+    map["onPaste"] = MapBuilder.of(
+      "phasedRegistrationNames",
+      MapBuilder.of("bubbled", "onPaste")
+    )
+
+    return map
+  }
+
+  companion object {
+    const val NAME = "PasteTextInput"
+    const val CACHE_DIR_NAME = "mmPasteInput"
+  }
+}

package/android/src/main/java/com/mattermost/pasteinputtext/PasteTextInputPackage.kt

@@ -0,0 +1,14 @@
+package com.mattermost.pasteinputtext
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PasteTextInputPackage : ReactPackage {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    listOf(PasteTextInputManager(reactContext))
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    emptyList()
+}

package/android/src/main/java/com/mattermost/pasteinputtext/PasteTextInputPasteEvent.java

@@ -0,0 +1,41 @@
+package com.mattermost.pasteinputtext;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+
+public class PasteTextInputPasteEvent extends Event<PasteTextInputPasteEvent> {
+  private static final String EVENT_NAME = "onPaste";
+  private final ReadableMap mEventData;
+
+  @Deprecated
+  public PasteTextInputPasteEvent(int viewId) {
+    this(-1, viewId, null);
+  }
+
+  public PasteTextInputPasteEvent(int surfaceId, int viewId, ReadableMap eventData) {
+    super(surfaceId, viewId);
+    mEventData = eventData;
+  }
+
+  public boolean canCoalesce() {
+    return false;
+  }
+
+  @NonNull
+  public String getEventName() {
+    return EVENT_NAME;
+  }
+
+  @Nullable
+  protected WritableMap getEventData() {
+    WritableMap eventData = Arguments.createMap();
+    eventData.putInt("target", this.getViewTag());
+    eventData.merge(mEventData);
+    return eventData;
+  }
+}

package/android/src/main/java/com/mattermost/pasteinputtext/RealPathUtil.kt

@@ -0,0 +1,174 @@
+package com.mattermost.pasteinputtext
+
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import android.provider.OpenableColumns
+import android.util.Log
+import android.text.TextUtils
+import java.io.*
+
+object RealPathUtil {
+  init {
+    deleteTempFiles(File(PasteTextInputManager.CACHE_DIR_NAME))
+  }
+
+  fun getRealPathFromURI(context: Context, uri: Uri): String? {
+    // DocumentProvider
+    if (DocumentsContract.isDocumentUri(context, uri)) {
+      // ExternalStorageProvider
+      if (isExternalStorageDocument(uri)) {
+        val docId = DocumentsContract.getDocumentId(uri)
+        val split = docId.split((":").toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val type = split[0]
+        if ("primary".equals(type, ignoreCase = true)) {
+          return context.getExternalFilesDir(split[1])?.absolutePath
+        }
+      } else if (isDownloadsDocument(uri)) {
+        // DownloadsProvider
+        val id = DocumentsContract.getDocumentId(uri)
+        if (!TextUtils.isEmpty(id)) {
+          if (id.startsWith("raw:")) {
+            return id.replaceFirst(("raw:").toRegex(), "")
+          }
+          try {
+            return getPathFromSavingTempFile(context, uri)
+          } catch (e: NumberFormatException) {
+            Log.e("ReactNative", "DownloadsProvider unexpected uri $uri")
+            return null
+          }
+        }
+      } else if (isMediaDocument(uri)) {
+        // MediaProvider
+        val docId = DocumentsContract.getDocumentId(uri)
+        val split = docId.split((":").toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val type = split[0]
+        var contentUri: Uri? = null
+        when (type) {
+            "image" -> {
+              contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+            }
+            "video" -> {
+              contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+            }
+            "audio" -> {
+              contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+            }
+        }
+        val selectionArgs = arrayOf(split[1])
+        return contentUri?.let { getDataColumn(context, it, selectionArgs) }
+      }
+    }
+    if ("content".equals(uri.scheme, ignoreCase = true)) {
+      // MediaStore (and general)
+      if (isGooglePhotosUri(uri)) {
+        return uri.lastPathSegment
+      }
+      // Try save to tmp file, and return tmp file path
+      return getPathFromSavingTempFile(context, uri)
+    } else if ("file".equals(uri.scheme, ignoreCase = true)) {
+      return uri.path
+    }
+    return null
+  }
+
+  private fun getPathFromSavingTempFile(context: Context, uri: Uri): String? {
+    val tmpFile: File
+    var fileName: String? = null
+    // Try and get the filename from the Uri
+    try {
+      val returnCursor = context.contentResolver.query(uri, null, null, null, null)
+      val nameIndex = returnCursor?.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+      returnCursor?.moveToFirst()
+      fileName = sanitizeFilename(nameIndex?.let { returnCursor.getString(it) })
+      returnCursor?.close()
+    } catch (e: Exception) {
+      // just continue to get the filename with the last segment of the path
+    }
+    try {
+      if (fileName == null) {
+        fileName = sanitizeFilename(uri.lastPathSegment.toString().trim())
+      }
+      val cacheDir = File(context.cacheDir, PasteTextInputManager.CACHE_DIR_NAME)
+      if (!cacheDir.exists()) {
+        cacheDir.mkdirs()
+      }
+
+      tmpFile = fileName?.let { File(cacheDir, it) }!!
+      tmpFile.createNewFile()
+      val pfd = context.contentResolver.openFileDescriptor(uri, "r")
+      val src = FileInputStream(pfd?.fileDescriptor).channel
+      val dst = FileOutputStream(tmpFile).channel
+      dst.transferFrom(src, 0, src.size())
+      src.close()
+      dst.close()
+      pfd?.close()
+    } catch (ex: IOException) {
+      return null
+    }
+    return tmpFile.absolutePath
+  }
+
+  private fun sanitizeFilename(filename: String?): String? {
+    if (filename == null) {
+      return null
+    }
+
+    val f = File(filename)
+    return f.name
+  }
+
+  private fun getDataColumn(context: Context, uri: Uri,
+                            selectionArgs: Array<String>): String? {
+    var cursor: Cursor? = null
+    val column = "_data"
+    val selection = "_id=?"
+    val projection = arrayOf(column)
+    try {
+      cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
+      if (cursor != null && cursor.moveToFirst()) {
+        val index = cursor.getColumnIndexOrThrow(column)
+        return cursor.getString(index)
+      }
+    } finally {
+      cursor?.close()
+    }
+
+    return null
+  }
+
+  private fun isExternalStorageDocument(uri: Uri): Boolean {
+    return "com.android.externalstorage.documents" == uri.authority
+  }
+
+  private fun isDownloadsDocument(uri: Uri): Boolean {
+    return "com.android.providers.downloads.documents" == uri.authority
+  }
+
+  private fun isMediaDocument(uri: Uri): Boolean {
+    return "com.android.providers.media.documents" == uri.authority
+  }
+
+  private fun isGooglePhotosUri(uri: Uri): Boolean {
+    return "com.google.android.apps.photos.content" == uri.authority
+  }
+
+    private fun deleteTempFiles(dir: File) {
+    try {
+      if (dir.isDirectory) {
+        deleteRecursive(dir)
+      }
+    } catch (e: Exception) {
+      // do nothing
+    }
+  }
+
+  private fun deleteRecursive(fileOrDirectory: File) {
+    if (fileOrDirectory.isDirectory)
+      for (child in fileOrDirectory.listFiles()!!)
+        deleteRecursive(child)
+    fileOrDirectory.delete()
+  }
+}

package/ios/NSData+MimeType.h

@@ -0,0 +1,20 @@
+//
+//  NSData+MimeType.h
+//  Mattermost
+//
+//  Created by Tek Min Ewe on 04/08/2019.
+//  Copyright © 2019 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NSData (MimeType)
+
+-(NSString *)mimeType;
+-(NSString *)extension;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NSData+MimeType.m

@@ -0,0 +1,59 @@
+//
+//  NSData+MimeType.m
+//  Mattermost
+//
+//  Created by Tek Min Ewe on 04/08/2019.
+//  Copyright © 2019 Facebook. All rights reserved.
+//
+
+#import "NSData+MimeType.h"
+
+@implementation NSData (MimeType)
+
+-(NSString *)mimeType {
+  uint8_t c;
+  [self getBytes:&c length:1];
+  
+  switch (c) {
+    case 0xFF:
+      return @"image/jpeg";
+      break;
+    case 0x89:
+      return @"image/png";
+      break;
+    case 0x47:
+      return @"image/gif";
+      break;
+    case 0x49:
+    case 0x4D:
+      return @"image/tiff";
+      break;
+    default:
+      return @"";
+  }
+}
+
+-(NSString *)extension {
+  uint8_t c;
+  [self getBytes:&c length:1];
+  
+  switch (c) {
+    case 0xFF:
+      return @"jpg";
+      break;
+    case 0x89:
+      return @"png";
+      break;
+    case 0x47:
+      return @"gif";
+      break;
+    case 0x49:
+    case 0x4D:
+      return @"tiff";
+      break;
+    default:
+      return @"";
+  }
+}
+
+@end

package/ios/PasteInput-Bridging-Header.h

@@ -0,0 +1 @@
+