@os1-platform/dispatch-mobile 1.0.0

package/android/src/main/java/com/dispatchsdk/signaturePad/RSSignatureCaptureView.kt

@@ -0,0 +1,355 @@
+package com.dispatchsdk.signaturePad
+
+import android.content.Context
+import android.graphics.*
+import android.util.DisplayMetrics
+import android.view.MotionEvent
+import android.view.View
+import android.widget.LinearLayout
+import com.dispatchsdk.signatureUtils.Bezier
+import com.dispatchsdk.signatureUtils.ControlTimedPoints
+import com.dispatchsdk.signatureUtils.TimedPoint
+import kotlin.math.abs
+import kotlin.math.roundToInt
+import kotlin.math.sqrt
+
+class RSSignatureCaptureView(context: Context, private val callback: SignatureCallback) :
+  View(context) {
+  private var mIsEmpty = false
+  private val mOnSignedListener: OnSignedListener? = null
+  private var mMinWidth: Int
+  private var mMaxWidth: Int
+  private var mLastTouchX = 0f
+  private var mLastTouchY = 0f
+  private var mLastVelocity = 0f
+  private var mLastWidth = 0f
+  private val mDirtyRect: RectF
+  private var mPoints: MutableList<TimedPoint>? = null
+  private val mPaint = Paint()
+  private val mPath = Path()
+  private var mSignatureBitmap: Bitmap? = null
+  private val mVelocityFilterWeight: Float
+  private var mSignatureBitmapCanvas: Canvas? = null
+  private var dragged = false
+  private var multipleTouchDragged = false
+  private val scrollThreshold = 5// set the signature bitmap
+
+  // important for saving signature
+  /**
+   * Get signature
+   *
+   * @return
+   */
+  val signature: Bitmap
+    get() {
+      var signatureBitmap: Bitmap? = null
+
+      // set the signature bitmap
+      if (signatureBitmap == null) {
+        signatureBitmap =
+          Bitmap.createBitmap(this.width, this.height, Bitmap.Config.ARGB_8888)
+      }
+
+      // important for saving signature
+      val canvas = Canvas(signatureBitmap!!)
+      draw(canvas)
+      return signatureBitmap
+    }
+
+  /**
+   * clear signature canvas
+   */
+  fun clearSignature() {
+    clear()
+  }
+
+  private fun addPoint(newPoint: TimedPoint) {
+    mPoints!!.add(newPoint)
+    if (mPoints!!.size > 2) {
+      // To reduce the initial lag make it work with 3 mPoints
+      // by copying the first point to the beginning.
+      if (mPoints!!.size == 3) mPoints!!.add(0, mPoints!![0])
+      var tmp = calculateCurveControlPoints(mPoints!![0], mPoints!![1], mPoints!![2])
+      val c2 = tmp.c2
+      tmp = calculateCurveControlPoints(mPoints!![1], mPoints!![2], mPoints!![3])
+      val c3 = tmp.c1
+      val curve = Bezier(mPoints!![1], c2, c3, mPoints!![2])
+      val startPoint = curve.startPoint
+      val endPoint = curve.endPoint
+      var velocity = endPoint.velocityFrom(startPoint)
+      velocity = if (java.lang.Float.isNaN(velocity)) 0.0f else velocity
+      velocity = (mVelocityFilterWeight * velocity
+        + (1 - mVelocityFilterWeight) * mLastVelocity)
+
+      // The new width is a function of the velocity. Higher velocities
+      // correspond to thinner strokes.
+      val newWidth = strokeWidth(velocity)
+
+      // The Bezier's width starts out as last curve's final width, and
+      // gradually changes to the stroke width just calculated. The new
+      // width calculation is based on the velocity between the Bezier's
+      // start and end mPoints.
+      addBezier(curve, mLastWidth, newWidth)
+      mLastVelocity = velocity
+      mLastWidth = newWidth
+
+      // Remove the first element from the list,
+      // so that we always have no more than 4 mPoints in mPoints array.
+      mPoints!!.removeAt(0)
+    }
+  }
+
+  private fun addBezier(curve: Bezier, startWidth: Float, endWidth: Float) {
+    ensureSignatureBitmap()
+    val originalWidth = mPaint.strokeWidth
+    val widthDelta = endWidth - startWidth
+    val drawSteps = Math.floor(curve.length().toDouble()).toFloat()
+    var i = 0
+    while (i < drawSteps) {
+
+      // Calculate the Bezier (x, y) coordinate for this step.
+      val t = i.toFloat() / drawSteps
+      val tt = t * t
+      val ttt = tt * t
+      val u = 1 - t
+      val uu = u * u
+      val uuu = uu * u
+      var x = uuu * curve.startPoint.x
+      x += 3 * uu * t * curve.control1.x
+      x += 3 * u * tt * curve.control2.x
+      x += ttt * curve.endPoint.x
+      var y = uuu * curve.startPoint.y
+      y += 3 * uu * t * curve.control1.y
+      y += 3 * u * tt * curve.control2.y
+      y += ttt * curve.endPoint.y
+
+      // Set the incremental stroke width and draw.
+      mPaint.strokeWidth = startWidth + ttt * widthDelta
+      mSignatureBitmapCanvas!!.drawPoint(x, y, mPaint)
+      expandDirtyRect(x, y)
+      i++
+    }
+    mPaint.strokeWidth = originalWidth
+  }
+
+  private fun ensureSignatureBitmap() {
+    if (mSignatureBitmap == null) {
+      mSignatureBitmap = Bitmap.createBitmap(
+        width, height,
+        Bitmap.Config.ARGB_8888
+      )
+      mSignatureBitmapCanvas = Canvas(mSignatureBitmap!!)
+    }
+  }
+
+  fun setMinStrokeWidth(minStrokeWidth: Int) {
+    mMinWidth = minStrokeWidth
+  }
+
+  fun setMaxStrokeWidth(maxStrokeWidth: Int) {
+    mMaxWidth = maxStrokeWidth
+  }
+
+  fun setStrokeColor(color: Int) {
+    mPaint.color = color
+  }
+
+  private fun strokeWidth(velocity: Float): Float {
+    return Math.max(mMaxWidth / (velocity + 1), mMinWidth.toFloat())
+  }
+
+  private fun calculateCurveControlPoints(
+    s1: TimedPoint,
+    s2: TimedPoint,
+    s3: TimedPoint
+  ): ControlTimedPoints {
+    val dx1 = s1.x - s2.x
+    val dy1 = s1.y - s2.y
+    val dx2 = s2.x - s3.x
+    val dy2 = s2.y - s3.y
+    val m1 = TimedPoint((s1.x + s2.x) / 2.0f, (s1.y + s2.y) / 2.0f)
+    val m2 = TimedPoint((s2.x + s3.x) / 2.0f, (s2.y + s3.y) / 2.0f)
+    val l1 = sqrt((dx1 * dx1 + dy1 * dy1).toDouble()).toFloat()
+    val l2 = sqrt((dx2 * dx2 + dy2 * dy2).toDouble()).toFloat()
+    val dxm = m1.x - m2.x
+    val dym = m1.y - m2.y
+    val k = l2 / (l1 + l2)
+    val cm = TimedPoint(m2.x + dxm * k, m2.y + dym * k)
+    val tx = s2.x - cm.x
+    val ty = s2.y - cm.y
+    return ControlTimedPoints(
+      TimedPoint(m1.x + tx, m1.y + ty),
+      TimedPoint(m2.x + tx, m2.y + ty)
+    )
+  }
+
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    if (!isEnabled || event.pointerCount > 1 || multipleTouchDragged && event.action != MotionEvent.ACTION_UP) {
+      multipleTouchDragged = true
+      return false
+    }
+    val eventX = event.x
+    val eventY = event.y
+    when (event.action) {
+      MotionEvent.ACTION_DOWN -> {
+        mLastTouchX = eventX
+        mLastTouchY = eventY
+        parent.requestDisallowInterceptTouchEvent(true)
+        mPoints!!.clear()
+        mPath.moveTo(eventX, eventY)
+        addPoint(TimedPoint(eventX, eventY))
+        if ((abs(mLastTouchX - eventX) < scrollThreshold || abs(mLastTouchY - eventY) < scrollThreshold) && dragged) {
+          return false
+        }
+        resetDirtyRect(eventX, eventY)
+        addPoint(TimedPoint(eventX, eventY))
+        dragged = true
+      }
+      MotionEvent.ACTION_MOVE -> {
+        if ((abs(mLastTouchX - eventX) < scrollThreshold || abs(mLastTouchY - eventY) < scrollThreshold) && dragged) {
+          return false
+        }
+        resetDirtyRect(eventX, eventY)
+        addPoint(TimedPoint(eventX, eventY))
+        dragged = true
+      }
+      MotionEvent.ACTION_UP -> {
+        if (mPoints!!.size >= 3) {
+          resetDirtyRect(eventX, eventY)
+          addPoint(TimedPoint(eventX, eventY))
+          parent.requestDisallowInterceptTouchEvent(true)
+          setIsEmpty(false)
+          sendDragEventToReact()
+        }
+        dragged = false
+        multipleTouchDragged = false
+      }
+      else -> return false
+    }
+
+    //invalidate();
+    invalidate(
+      (mDirtyRect.left - mMaxWidth).toInt(),
+      (mDirtyRect.top - mMaxWidth).toInt(),
+      (mDirtyRect.right + mMaxWidth).toInt(),
+      (mDirtyRect.bottom + mMaxWidth).toInt()
+    )
+    return true
+  }
+
+  private fun sendDragEventToReact() {
+    if (callback != null && dragged) {
+      callback.onDragged()
+    }
+  }
+
+  // all touch events during the drawing
+  override fun onDraw(canvas: Canvas) {
+    if (mSignatureBitmap != null) {
+      canvas.drawBitmap(mSignatureBitmap!!, 0f, 0f, mPaint)
+    }
+  }
+
+  /**
+   * Called when replaying history to ensure the dirty region includes all
+   * mPoints.
+   *
+   * @param historicalX the previous x coordinate.
+   * @param historicalY the previous y coordinate.
+   */
+  private fun expandDirtyRect(historicalX: Float, historicalY: Float) {
+    if (historicalX < mDirtyRect.left) {
+      mDirtyRect.left = historicalX
+    } else if (historicalX > mDirtyRect.right) {
+      mDirtyRect.right = historicalX
+    }
+    if (historicalY < mDirtyRect.top) {
+      mDirtyRect.top = historicalY
+    } else if (historicalY > mDirtyRect.bottom) {
+      mDirtyRect.bottom = historicalY
+    }
+  }
+
+  /**
+   * Resets the dirty region when the motion event occurs.
+   *
+   * @param eventX the event x coordinate.
+   * @param eventY the event y coordinate.
+   */
+  private fun resetDirtyRect(eventX: Float, eventY: Float) {
+
+    // The mLastTouchX and mLastTouchY were set when the ACTION_DOWN motion event occurred.
+    mDirtyRect.left = mLastTouchX.coerceAtMost(eventX)
+    mDirtyRect.right = mLastTouchX.coerceAtLeast(eventX)
+    mDirtyRect.top = mLastTouchY.coerceAtMost(eventY)
+    mDirtyRect.bottom = mLastTouchY.coerceAtLeast(eventY)
+  }
+
+  private fun setIsEmpty(newValue: Boolean) {
+    mIsEmpty = newValue
+    if (mOnSignedListener != null) {
+      if (mIsEmpty) {
+        mOnSignedListener.onClear()
+      } else {
+        mOnSignedListener.onSigned()
+      }
+    }
+  }
+
+  fun clear() {
+    dragged = false
+    mPoints = ArrayList()
+    mLastVelocity = 0f
+    mLastWidth = ((mMinWidth + mMaxWidth) / 2).toFloat()
+    mPath.reset()
+    if (mSignatureBitmap != null) {
+      mSignatureBitmap = null
+      ensureSignatureBitmap()
+    }
+    setIsEmpty(true)
+    invalidate()
+  }
+
+  private fun convertDpToPx(dp: Float): Int {
+    return (dp * (resources.displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT)).roundToInt()
+  }
+
+  interface SignatureCallback {
+    fun onDragged()
+  }
+
+  interface OnSignedListener {
+    fun onSigned()
+    fun onClear()
+  }
+
+  companion object {
+    private const val STROKE_WIDTH = 5f
+  }
+
+  init {
+
+    //Fixed parameters
+    mPaint.isAntiAlias = true
+    mPaint.style = Paint.Style.STROKE
+    mPaint.strokeCap = Paint.Cap.ROUND
+    mPaint.strokeJoin = Paint.Join.ROUND
+    mMinWidth = convertDpToPx(8f)
+    mMaxWidth = convertDpToPx(16f)
+    mVelocityFilterWeight = 0.4f
+    mPaint.color = Color.BLACK
+
+    //Dirty rectangle to update only the changed portion of the view
+    mDirtyRect = RectF()
+    clear()
+
+    // set the bg color as white
+    setBackgroundColor(Color.WHITE)
+
+    // width and height should cover the screen
+    this.layoutParams = LinearLayout.LayoutParams(
+      LinearLayout.LayoutParams.MATCH_PARENT,
+      LinearLayout.LayoutParams.MATCH_PARENT
+    )
+  }
+}

package/android/src/main/java/com/dispatchsdk/signaturePad/RSSignatureCaptureViewManager.kt

@@ -0,0 +1,132 @@
+package com.dispatchsdk.signaturePad
+
+import android.graphics.Color
+import android.util.Log
+import com.dispatchsdk.utils.Utils.parseColor
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class RSSignatureCaptureViewManager(reactContext: ReactApplicationContext) :
+  ViewGroupManager<RSSignatureCaptureMainView>() {
+  private val mContextModule: RSSignatureCaptureContextModule = RSSignatureCaptureContextModule(
+    reactContext
+  )
+
+  override fun getName(): String {
+    return "RSSignatureView"
+  }
+
+  @ReactProp(name = PROPS_VIEW_MODE)
+  fun setViewMode(view: RSSignatureCaptureMainView?, viewMode: String?) {
+    Log.d("setViewMode:", "" + viewMode)
+    view?.setViewMode(viewMode!!)
+  }
+
+  @ReactProp(name = PROPS_SHOW_NATIVE_BUTTONS)
+  fun setPropsShowNativeButtons(view: RSSignatureCaptureMainView?, showNativeButtons: Boolean?) {
+    Log.d("showNativeButtons:", "" + showNativeButtons)
+    view?.setShowNativeButtons(showNativeButtons!!)
+  }
+
+  @ReactProp(name = PROPS_MAX_SIZE)
+  fun setPropsWidth(view: RSSignatureCaptureMainView?, maxSize: Int?) {
+    Log.d("maxSize:", "" + maxSize)
+    view?.setMaxSize(maxSize!!)
+  }
+
+  @ReactProp(name = PROPS_MIN_STROKE_WIDTH)
+  fun setPropsMinStrokeWidth(view: RSSignatureCaptureMainView?, minStrokeWidth: Int) {
+    Log.d("minStrokeWidth:", "" + minStrokeWidth)
+    if (view != null) {
+      view.signatureView!!.setMinStrokeWidth(minStrokeWidth)
+    }
+  }
+
+  @ReactProp(name = PROPS_MAX_STROKE_WIDTH)
+  fun setPropsMaxStrokeWidth(view: RSSignatureCaptureMainView?, maxStrokeWidth: Int) {
+    Log.d("maxStrokeWidth:", "" + maxStrokeWidth)
+    if (view != null) {
+      view.signatureView!!.setMaxStrokeWidth(maxStrokeWidth)
+    }
+  }
+
+  @ReactProp(name = PROPS_STROKE_COLOR)
+  fun setPropsStrokeColor(view: RSSignatureCaptureMainView?, color: String?) {
+    Log.d("strokeColor:", "" + color)
+    if (view != null) {
+      view.signatureView!!.setStrokeColor(parseColor(color))
+    }
+  }
+
+  @ReactProp(name = PROPS_BACKGROUND_COLOR)
+  fun setPropsBackgroundColor(view: RSSignatureCaptureMainView?, color: String?) {
+    val parsed: Int = if (color.equals("transparent", ignoreCase = true)) {
+      Color.TRANSPARENT
+    } else {
+      Color.parseColor(color)
+    }
+    Log.d("backgroundColor:", "" + color)
+    if (view != null) {
+      view.signatureView!!.setBackgroundColor(parsed)
+    }
+  }
+
+  public override fun createViewInstance(context: ThemedReactContext): RSSignatureCaptureMainView {
+    Log.d("React", " View manager createViewInstance:")
+    return RSSignatureCaptureMainView(context, mContextModule.activity!!)
+  }
+
+  override fun getCommandsMap(): Map<String, Int>? {
+    Log.d("React", " View manager getCommandsMap:")
+    return MapBuilder.of(
+      "saveImage",
+      COMMAND_SAVE_IMAGE,
+      "resetImage",
+      COMMAND_RESET_IMAGE
+    )
+  }
+
+  override fun receiveCommand(
+    view: RSSignatureCaptureMainView,
+    commandType: Int,
+    args: ReadableArray?
+  ) {
+    Assertions.assertNotNull(view)
+    Assertions.assertNotNull(args)
+    when (commandType) {
+      COMMAND_SAVE_IMAGE -> {
+        view.saveImage()
+        return
+      }
+      COMMAND_RESET_IMAGE -> {
+        view.reset()
+        return
+      }
+      else -> throw IllegalArgumentException(
+        String.format(
+          "Unsupported command %d received by %s.",
+          commandType,
+          javaClass.simpleName
+        )
+      )
+    }
+  }
+
+  companion object {
+    const val PROPS_VIEW_MODE = "viewMode"
+    const val PROPS_SHOW_NATIVE_BUTTONS = "showNativeButtons"
+    const val PROPS_MAX_SIZE = "maxSize"
+    const val PROPS_MIN_STROKE_WIDTH = "minStrokeWidth"
+    const val PROPS_MAX_STROKE_WIDTH = "maxStrokeWidth"
+    const val PROPS_STROKE_COLOR = "strokeColor"
+    const val PROPS_BACKGROUND_COLOR = "backgroundColor"
+    const val COMMAND_SAVE_IMAGE = 1
+    const val COMMAND_RESET_IMAGE = 2
+  }
+
+}

package/android/src/main/java/com/dispatchsdk/signatureUtils/Bezier.kt

@@ -0,0 +1,45 @@
+package com.dispatchsdk.signatureUtils
+
+import kotlin.math.sqrt
+
+class Bezier(
+  var startPoint: TimedPoint, var control1: TimedPoint,
+  var control2: TimedPoint, var endPoint: TimedPoint
+) {
+  fun length(): Float {
+    val steps = 10
+    var length = 0
+    var t: Float
+    var cx: Double
+    var cy: Double
+    var px = 0.0
+    var py = 0.0
+    var xdiff: Double
+    var ydiff: Double
+    var i = 0
+    while (i <= steps) {
+      t = (i / steps).toFloat()
+      cx = point(
+        t, startPoint.x, control1.x,
+        control2.x, endPoint.x
+      )
+      cy = point(
+        t, startPoint.y, control1.y,
+        control2.y, endPoint.y
+      )
+      if (i > 0) {
+        xdiff = cx - px
+        ydiff = cy - py
+        length += sqrt(xdiff * xdiff + ydiff * ydiff).toInt()
+      }
+      px = cx
+      py = cy
+      i++
+    }
+    return length.toFloat()
+  }
+
+  private fun point(t: Float, start: Float, c1: Float, c2: Float, end: Float): Double {
+    return start * (1.0 - t) * (1.0 - t) * (1.0 - t) + 3.0 * c1 * (1.0 - t) * (1.0 - t) * t + 3.0 * c2 * (1.0 - t) * t * t + end * t * t * t
+  }
+}

package/android/src/main/java/com/dispatchsdk/signatureUtils/ControlTimedPoints.kt

@@ -0,0 +1,3 @@
+package com.dispatchsdk.signatureUtils
+
+data class ControlTimedPoints(var c1: TimedPoint, var c2: TimedPoint)

package/android/src/main/java/com/dispatchsdk/signatureUtils/TimedPoint.kt

@@ -0,0 +1,19 @@
+package com.dispatchsdk.signatureUtils
+
+import kotlin.math.pow
+import kotlin.math.sqrt
+
+class TimedPoint(val x: Float, val y: Float) {
+  private val timestamp: Long = System.currentTimeMillis()
+  fun velocityFrom(start: TimedPoint): Float {
+    val velocity = distanceTo(start) / (timestamp - start.timestamp)
+    return if (velocity != velocity) 0f else velocity
+  }
+
+  private fun distanceTo(point: TimedPoint): Float {
+    return sqrt(
+      (point.x - x).toDouble().pow(2.0) + (point.y - y).toDouble().pow(2.0)
+    ).toFloat()
+  }
+
+}

package/android/src/main/java/com/dispatchsdk/sync/SyncEventService.kt

@@ -0,0 +1,28 @@
+package com.dispatchsdk.sync
+
+import android.content.Intent
+import androidx.annotation.Nullable
+import com.dispatchsdk.utils.ModuleConfig
+import com.dispatchsdk.utils.Tracer
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+
+
+class SyncEventService : HeadlessJsTaskService() {
+  companion object {
+    private const val TAG = ModuleConfig.TAG + "SyncEventService"
+  }
+
+  @Nullable
+  override fun getTaskConfig(intent: Intent): HeadlessJsTaskConfig {
+    Tracer.debug(TAG, "getTaskConfig ")
+    val extras = intent.extras
+    return HeadlessJsTaskConfig(
+      ModuleConfig.SYNC_TASK_KEY,
+      if (extras != null) Arguments.fromBundle(extras) else Arguments.createMap(),
+      5000, // timeout for the task
+      true // optional: defines whether or not  the task is allowed in foreground. Default is false
+    )
+  }
+}