@sumsub/cordova-idensic-mobile-sdk-plugin 1.18.1

package/demo/plugins/cordova-plugin-timer/src/android/NativeTimerPlugin.java

@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) 2018, kitolog
+ * All rights reserved.
+ * <p>
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by kitolog. The name of the
+ * kitolog may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+package com.applurk.nativetimer;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaArgs;
+import org.apache.cordova.CordovaPlugin;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class NativeTimerPlugin extends CordovaPlugin {
+
+    Map<String, NativeTimerAdapter> nativeTimerAdapters = new HashMap<String, NativeTimerAdapter>();
+
+    @Override
+    public boolean execute(String action, CordovaArgs args, CallbackContext callbackContext) throws JSONException {
+        if (action.equals("start")) {
+            this.start(args, callbackContext);
+        } else if (action.equals("stop")) {
+            this.stop(args, callbackContext);
+        } else {
+            callbackContext.error(String.format("NativeTimerPlugin - invalid action:", action));
+            return false;
+        }
+        return true;
+    }
+
+    private void start(CordovaArgs args, CallbackContext callbackContext) throws JSONException {
+        String timerKey = args.getString(0);
+        int delay = args.getInt(1);
+        int interval = args.getInt(2);
+
+        NativeTimerAdapter nativeTimerAdapter = new NativeTimerAdapterImpl();
+        nativeTimerAdapter.setStopEventHandler(new StopEventHandler(timerKey));
+        nativeTimerAdapter.setTickHandler(new TickConsumer(timerKey));
+        nativeTimerAdapter.setErrorEventHandler(new ErrorEventHandler(timerKey));
+        nativeTimerAdapter.setStartEventHandler(new StartEventHandler(timerKey, nativeTimerAdapter, callbackContext));
+
+        nativeTimerAdapter.start(delay, interval);
+    }
+
+    private void stop(CordovaArgs args, CallbackContext callbackContext) throws JSONException {
+        String timerKey = args.getString(0);
+        NativeTimerAdapter nativeTimerAdapter = this.getNativeTimerAdapter(timerKey);
+        nativeTimerAdapter.stop();
+        callbackContext.success();
+    }
+
+    private NativeTimerAdapter getNativeTimerAdapter(String timerKey) {
+        if (!this.nativeTimerAdapters.containsKey(timerKey)) {
+            throw new IllegalStateException("NativeTimer isn't connected.");
+        }
+        return this.nativeTimerAdapters.get(timerKey);
+    }
+
+    private void dispatchEvent(JSONObject jsonEventObject) {
+        this.webView.sendJavascript(String.format("window.nativeTimer.dispatchEvent(%s);", jsonEventObject.toString()));
+    }
+
+    private class StopEventHandler implements Consumer<Boolean> {
+        private String timerKey;
+
+        public StopEventHandler(String timerKey) {
+            this.timerKey = timerKey;
+        }
+
+        @Override
+        public void accept(Boolean hasError) {
+            nativeTimerAdapters.remove(this.timerKey);
+
+            try {
+                JSONObject event = new JSONObject();
+                event.put("type", "OnStop");
+                event.put("hasError", hasError.booleanValue());
+                event.put("timerKey", this.timerKey);
+
+                dispatchEvent(event);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private class TickConsumer implements Consumer<Integer> {
+        private String timerKey;
+
+        public TickConsumer(String timerKey) {
+            this.timerKey = timerKey;
+        }
+
+        @Override
+        public void accept(Integer tick) {
+            try {
+                JSONObject event = new JSONObject();
+                event.put("type", "OnTick");
+                event.put("data", tick);
+                event.put("timerKey", timerKey);
+
+                dispatchEvent(event);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private class ErrorEventHandler implements Consumer<String> {
+        private String timerKey;
+
+        public ErrorEventHandler(String timerKey) {
+            this.timerKey = timerKey;
+        }
+
+        @Override
+        public void accept(String errorMessage) {
+            try {
+                JSONObject event = new JSONObject();
+                event.put("type", "OnError");
+                event.put("errorMessage", errorMessage);
+                event.put("timerKey", timerKey);
+
+                dispatchEvent(event);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private class StartEventHandler implements Consumer<Void> {
+        private String timerKey;
+        private NativeTimerAdapter nativeTimerAdapter;
+        private CallbackContext openCallbackContext;
+
+        public StartEventHandler(String timerKey, NativeTimerAdapter nativeTimerAdapter, CallbackContext openCallbackContext) {
+            this.timerKey = timerKey;
+            this.nativeTimerAdapter = nativeTimerAdapter;
+            this.openCallbackContext = openCallbackContext;
+        }
+
+        @Override
+        public void accept(Void voidObject) {
+            nativeTimerAdapters.put(timerKey, nativeTimerAdapter);
+            this.openCallbackContext.success();
+        }
+    }
+}

package/demo/plugins/cordova-plugin-timer/src/ios/NativeTimerAdapter.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2018, kitolog
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by kitolog. The name of the
+ * kitolog may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#import <Foundation/Foundation.h>
+
+@interface NativeTimerAdapter : NSObject <NSStreamDelegate> {
+@public
+    NSTimer *timerInstance;
+}
+
+- (void)start:(NSNumber *)delay interval:(NSNumber*)interval;
+- (void)stop;
+//- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)event;
+
+@property (copy) void (^startEventHandler)();
+@property (copy) void (^startErrorEventHandler)(NSString*);
+@property (copy) void (^tickHandler)(NSNumber*);
+@property (copy) void (^stopEventHandler)(BOOL);
+@property (copy) void (^errorEventHandler)(NSString*, NSString *);
+
+@end

package/demo/plugins/cordova-plugin-timer/src/ios/NativeTimerAdapter.m

@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2018, kitolog
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by kitolog. The name of the
+ * kitolog may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+//#include <netdb.h>
+//#include <arpa/inet.h>
+//#include <math.h>
+#import "NativeTimerAdapter.h"
+
+NSTimer *timerInstance;
+
+BOOL wasStarted = FALSE;
+float delay = 0.0;
+float interval = 1.0;
+
+int tick = 0;
+
+/**
+ * interval - float
+ */
+ 
+@implementation NativeTimerAdapter
+
+- (void)start:(NSNumber *)delay interval:(NSNumber*)interval {
+
+    NSLog(@"[TIMER] START timer delay: %@ interval: %@", [delay stringValue], [interval stringValue]);
+    
+    tick = 0;
+    double delayDouble = [delay doubleValue] / 1000;
+    double intervalDouble = [interval doubleValue] / 1000;
+    NSDate *fireDate = [NSDate dateWithTimeIntervalSinceNow:delayDouble];
+    NSTimer *timer = [[NSTimer alloc] initWithFireDate: fireDate
+                                          interval: intervalDouble
+                                            target: self
+                                          selector:@selector(onTimerTick:)
+                                          userInfo:nil repeats:YES];
+//    NSTimer *timer = [NSTimer timerWithTimeInterval:interval target:self selector:@selector(onTimerTick:) userInfo:nil repeats:YES];
+    [[NSRunLoop mainRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
+    timerInstance = timer;
+    self.startEventHandler();
+    wasStarted = TRUE;
+}
+
+-(void)onTimerTick:(NSTimer *)timer {
+    tick++;
+    NSLog(@"[TIMER] On timer tick: %d", tick);
+    NSNumber* tickNumber = [NSNumber numberWithInteger:tick];
+    self.tickHandler(tickNumber);
+}
+
+- (void)stop {
+    NSLog(@"[TIMER] timerInstance STOP");
+    self.stopEventHandler(FALSE);
+    if(timerInstance != nil){
+        [timerInstance invalidate];
+        timerInstance = nil;
+        NSLog(@"[TIMER] timerInstance invalidated");
+    }else{
+        NSLog(@"[TIMER] timerInstance not found");
+    }
+}
+
+@end

package/demo/plugins/cordova-plugin-timer/src/ios/NativeTimerPlugin.h

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2018, kitolog
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by kitolog. The name of the
+ * kitolog may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#import <Cordova/CDV.h>
+
+@interface NativeTimerPlugin : CDVPlugin {
+    NSMutableDictionary *timerAdapters;
+}
+
+-(void) start: (CDVInvokedUrlCommand *) command;
+-(void) stop: (CDVInvokedUrlCommand *) command;
+-(void) setOptions: (CDVInvokedUrlCommand *) command;
+
+@end

package/demo/plugins/cordova-plugin-timer/src/ios/NativeTimerPlugin.m

@@ -0,0 +1,158 @@
+/**
+ * Copyright (c) 2018, kitolog
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by kitolog. The name of the
+ * kitolog may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#import "NativeTimerPlugin.h"
+#import "NativeTimerAdapter.h"
+#import <cordova/CDV.h>
+#import <Foundation/Foundation.h>
+
+@implementation NativeTimerPlugin : CDVPlugin
+
+- (void) start : (CDVInvokedUrlCommand*) command {
+    
+    NSLog(@"[TIMER] call");
+    NSString *timerKey = [command.arguments objectAtIndex:0];
+    NSNumber *delay = [command.arguments objectAtIndex:1];
+    NSNumber *interval = [command.arguments objectAtIndex:2];
+
+    NSLog(@"[TIMER] start %@", timerKey);
+    if (timerAdapters == nil) {
+        self->timerAdapters = [[NSMutableDictionary alloc] init];
+    }
+
+    __block NativeTimerAdapter* timerAdapter = [[NativeTimerAdapter alloc] init];
+    timerAdapter.startEventHandler = ^ void () {
+        [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK] callbackId:command.callbackId];
+
+        [self->timerAdapters setObject:timerAdapter forKey:timerKey];
+
+        timerAdapter = nil;
+    };
+    
+    timerAdapter.startErrorEventHandler = ^ void (NSString *error){
+        NSLog(@"[TIMER] startErrorEventHandler");
+        [self.commandDelegate
+         sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:error]
+         callbackId:command.callbackId];
+    };
+    
+    timerAdapter.errorEventHandler = ^ void (NSString *error, NSString *errorType){
+        NSMutableDictionary *errorDictionaryData = [[NSMutableDictionary alloc] init];
+        [errorDictionaryData setObject:@"OnError" forKey:@"type"];
+        [errorDictionaryData setObject:errorType forKey:@"errorType"];
+        [errorDictionaryData setObject:error forKey:@"errorMessage"];
+        [errorDictionaryData setObject:timerKey forKey:@"timerKey"];
+
+        [self dispatchEventWithDictionary:errorDictionaryData];
+    };
+    timerAdapter.tickHandler = ^ void (NSNumber* data) {
+        NSMutableDictionary *dataDictionary = [[NSMutableDictionary alloc] init];
+        [dataDictionary setObject:@"OnTick" forKey:@"type"];
+        [dataDictionary setObject:data forKey:@"data"];
+        [dataDictionary setObject:timerKey forKey:@"timerKey"];
+
+        [self dispatchEventWithDictionary:dataDictionary];
+    };
+    timerAdapter.stopEventHandler = ^ void (BOOL hasErrors) {
+        NSLog(@"[TIMER] stopEventHandler");
+        NSMutableDictionary *closeDictionaryData = [[NSMutableDictionary alloc] init];
+        [closeDictionaryData setObject:@"OnStop" forKey:@"type"];
+        [closeDictionaryData setObject:(hasErrors == TRUE ? @"true": @"false") forKey:@"hasError"];
+        [closeDictionaryData setObject:timerKey forKey:@"timerKey"];
+
+        [self dispatchEventWithDictionary:closeDictionaryData];
+
+        [self removeTimerAdapter:timerKey];
+    };
+
+    [self.commandDelegate runInBackground:^{
+        @try {
+            [timerAdapter start:delay interval:interval];
+        }
+        @catch (NSException *e) {
+            [self.commandDelegate
+             sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:e.reason]
+             callbackId:command.callbackId];
+
+            timerAdapter = nil;
+        }
+    }];
+}
+
+- (void) stop:(CDVInvokedUrlCommand *) command {
+
+    NSString* timerKey = [command.arguments objectAtIndex:0];
+
+    NativeTimerAdapter *timerAdapter = [self getTimerAdapter:timerKey];
+
+    [self.commandDelegate runInBackground:^{
+        @try {
+            if (timerAdapter != nil) {
+                [timerAdapter stop];
+            }else{
+                NSLog(@"[TIMER] Stop: timerAdapter is nil. TimerKey: %@", timerKey);
+            }
+
+            [self.commandDelegate
+             sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK]
+             callbackId:command.callbackId];
+        }
+        @catch (NSException *e) {
+            [self.commandDelegate
+             sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:e.reason]
+             callbackId:command.callbackId];
+        }
+    }];
+}
+
+- (void) setOptions: (CDVInvokedUrlCommand *) command {
+}
+
+- (NativeTimerAdapter*) getTimerAdapter: (NSString*) timerKey {
+    NativeTimerAdapter* timerAdapter = [self->timerAdapters objectForKey:timerKey];
+    if (timerAdapter == nil) {
+        NSLog(@"[TIMER] Cannot find timerKey: %@. Connection is probably closed.", timerKey);
+        //NSString *exceptionReason = [NSString stringWithFormat:@"Cannot find timerKey: %@. Connection is probably closed.", timerKey];
+
+        //@throw [NSException exceptionWithName:@"IllegalArgumentException" reason:exceptionReason userInfo:nil];
+    }
+    return timerAdapter;
+}
+
+- (void) removeTimerAdapter: (NSString*) timerKey {
+    NSLog(@"[TIMER] Removing timer adapter from storage.");
+    [self->timerAdapters removeObjectForKey:timerKey];
+}
+
+- (BOOL) timerAdapterExists: (NSString*) timerKey {
+    NativeTimerAdapter* timerAdapter = [self->timerAdapters objectForKey:timerKey];
+    return timerAdapter != nil;
+}
+
+- (void) dispatchEventWithDictionary: (NSDictionary*) dictionary {
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:dictionary options:0 error:nil];
+    NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+
+    [self dispatchEvent:jsonString];
+}
+
+- (void) dispatchEvent: (NSString *) jsonEventString {
+    NSString *jsToEval = [NSString stringWithFormat : @"window.nativeTimer.dispatchEvent(%@);", jsonEventString];
+    [self.commandDelegate evalJs:jsToEval];
+}
+
+@end

package/demo/plugins/cordova-plugin-timer/types/index.d.ts

@@ -0,0 +1,21 @@
+
+interface Window {
+    nativeTimer: {
+        start(
+            delay: number,
+            interval: number,
+            successCallback: (status: number) => void,
+            errorCallback?: (fileError: NativeTimerError) => void): void;
+        stop(
+            successCallback: (status: number) => void,
+            errorCallback?: (fileError: NativeTimerError) => void): void;
+        checkState(
+            state: string,
+            errorCallback?: (fileError: NativeTimerError) => void): boolean;
+    }
+}
+
+interface NativeTimerError {
+    /** Error code */
+    code: number;
+}

package/demo/plugins/cordova-plugin-whitelist/CONTRIBUTING.md

@@ -0,0 +1,37 @@
+<!--
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+-->
+
+# Contributing to Apache Cordova
+
+Anyone can contribute to Cordova. And we need your contributions.
+
+There are multiple ways to contribute: report bugs, improve the docs, and
+contribute code.
+
+For instructions on this, start with the
+[contribution overview](http://cordova.apache.org/contribute/).
+
+The details are explained there, but the important items are:
+ - Sign and submit an Apache ICLA (Contributor License Agreement).
+ - Have a Jira issue open that corresponds to your contribution.
+ - Run the tests so your patch doesn't break existing functionality.
+
+We look forward to your contributions!