@cloudflare/realtimekit-react-native 0.0.0 → 0.0.1-staging.2

package/android/src/main/java/com/reactnativecore/DyteHelperModule.java

@@ -0,0 +1,268 @@
+package com.reactnativecore;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.os.Build;
+import android.os.Handler;
+import android.os.PowerManager;
+import android.util.Log;
+import android.view.WindowManager;
+
+import com.reactnativecore.ForegroundService;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.io.Serializable;
+import java.util.HashMap;
+
+import com.reactnativecore.DyteHolder;
+
+@ReactModule(name = "DyteHelperModule")
+public class DyteHelperModule extends ReactContextBaseJavaModule {
+
+    private final ReactApplicationContext reactContext;
+    private static final String ERROR_INVALID_ACTIVITY = "E_INVALID_ACTIVITY";
+
+    // react-native-background-timer start
+    private Handler handler;
+    private ReactContext reactContext2;
+    private Runnable runnable;
+    private PowerManager powerManager;
+    private PowerManager.WakeLock wakeLock;
+    private int existingOrientation;
+    private boolean isForcedLandscapeToggled;
+    private final LifecycleEventListener listener = new LifecycleEventListener() {
+        @Override
+        public void onHostResume() {
+        }
+
+        @Override
+        public void onHostPause() {
+        }
+
+        @Override
+        public void onHostDestroy() {
+            if (wakeLock.isHeld())
+                wakeLock.release();
+            Intent intent = new Intent(getReactApplicationContext(), ForegroundService.class);
+            intent.setAction(Constants.ACTION_FOREGROUND_SERVICE_STOP);
+            getReactApplicationContext().stopService(intent);
+        }
+    };
+    // react-native-background-timer end
+
+    private class Request {
+
+        public boolean[] rationaleStatuses;
+        public Callback callback;
+
+        public Request(boolean[] rationaleStatuses, Callback callback) {
+            this.rationaleStatuses = rationaleStatuses;
+            this.callback = callback;
+        }
+    }
+
+    public DyteHelperModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.powerManager = (PowerManager) getReactApplicationContext().getSystemService(reactContext.POWER_SERVICE);
+        this.wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "dytesdk:wakelock");
+        reactContext.addLifecycleEventListener(listener);
+    }
+
+    @Override
+    public String getName() {
+        return "DyteHelper";
+    }
+
+    @ReactMethod
+    public void createNotificationChannel(Promise promise) {
+        NotificationHelper.getInstance(getReactApplicationContext()).createNotificationChannel(promise);
+    }
+
+    @ReactMethod
+    public void startService(Promise promise) {
+        ComponentName mediaService;
+        DyteHolder.currActivity = this.getCurrentActivity();
+        Intent intent = new Intent(getReactApplicationContext(), ForegroundService.class);
+        intent.setAction(Constants.ACTION_FOREGROUND_SERVICE_START);
+        try{
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                mediaService = getReactApplicationContext().startForegroundService(intent);
+            } else {
+                mediaService = getReactApplicationContext().startService(intent);
+            } 
+        } catch (RuntimeException e) {
+            // Avoid crashing due to ForegroundServiceStartNotAllowedException (API level 31).
+            // See: https://developer.android.com/guide/components/foreground-services#background-start-restrictions
+            Log.w("DyteHelperModule", "Media projection service not started", e);
+            return;
+        }
+        if (mediaService != null) {
+            promise.resolve(null);
+        } else {
+            promise.reject(Constants.ERROR_SERVICE_ERROR, "DyteForegroundService: Foreground service is not started");
+        }
+    }
+
+    @ReactMethod
+    public void stopService(Promise promise) {
+        Intent intent = new Intent(getReactApplicationContext(), ForegroundService.class);
+        intent.setAction(Constants.ACTION_FOREGROUND_SERVICE_STOP);
+        boolean stopped = getReactApplicationContext().stopService(intent);
+        if (stopped) {
+            promise.resolve(null);
+        } else {
+            promise.reject(Constants.ERROR_SERVICE_ERROR, "DyteForegroundService: Foreground service failed to stop");
+        }
+    }
+    @ReactMethod
+    private void isForegroundServiceRunning(Promise promise) {
+        ActivityManager manager = (ActivityManager) this.getCurrentActivity().getSystemService(getReactApplicationContext().ACTIVITY_SERVICE);
+        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
+            if ((ForegroundService.class).getName().equals(service.service.getClassName())) {
+                promise.resolve(true);
+            }
+        }
+        promise.resolve(false);
+    }
+
+    @ReactMethod
+    public void activateScreenWake() {
+        final Activity activity = getCurrentActivity();
+
+        if (activity != null) {
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void deactivateScreenWake() {
+        final Activity activity = getCurrentActivity();
+
+        if (activity != null) {
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void forceLandscape() {
+        final Activity activity = getCurrentActivity();
+
+        if (activity != null) {
+            this.isForcedLandscapeToggled = true;
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    existingOrientation = activity.getRequestedOrientation();
+                    activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void forcePotrait() {
+        final Activity activity = getCurrentActivity();
+
+        if (activity != null) {
+            this.isForcedLandscapeToggled = true;
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    existingOrientation = activity.getRequestedOrientation();
+                    activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void resetOrientation() {
+        final Activity activity = getCurrentActivity();
+
+        if (activity != null) {
+            this.isForcedLandscapeToggled = false;
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    activity.setRequestedOrientation(existingOrientation);
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void isForcedLandscape(Promise p) {
+        p.resolve(this.isForcedLandscapeToggled);
+    }
+
+    @ReactMethod
+    public void backgroundTimerStart(final int delay) {
+        if (!wakeLock.isHeld())
+            wakeLock.acquire();
+
+        handler = new Handler();
+        runnable = new Runnable() {
+            @Override
+            public void run() {
+                backgroundTimerSendEvent(reactContext, "backgroundTimer");
+            }
+        };
+
+        handler.post(runnable);
+    }
+
+    @ReactMethod
+    public void backgroundTimerStop() {
+        if (wakeLock.isHeld())
+            wakeLock.release();
+
+        // avoid null pointer exceptio when stop is called without start
+        if (handler != null)
+            handler.removeCallbacks(runnable);
+    }
+
+    private void backgroundTimerSendEvent(ReactContext reactContext, String eventName) {
+        reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, null);
+    }
+
+    @ReactMethod
+    public void backgroundTimerSetTimeout(final int id, final double timeout) {
+        Handler handler = new Handler();
+        handler.postDelayed(new Runnable() {
+            @Override
+            public void run() {
+                if (getReactApplicationContext().hasActiveCatalystInstance()) {
+                    getReactApplicationContext()
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                            .emit("backgroundTimer.timeout", id);
+                }
+            }
+        }, (long) timeout);
+    }
+}

package/android/src/main/java/com/reactnativecore/DyteHolder.java

@@ -0,0 +1,7 @@
+package com.reactnativecore;
+
+import android.app.Activity;
+
+public class DyteHolder {
+    public static Activity currActivity;   
+}

package/android/src/main/java/com/reactnativecore/ForegroundService.java

@@ -0,0 +1,48 @@
+package com.reactnativecore;
+
+import android.app.Notification;
+import android.app.Service;
+import android.content.Intent;
+import android.content.Context;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.IBinder;
+import android.util.Log;
+import android.app.Activity;
+import android.widget.Toast;
+import com.reactnativecore.DyteHolder;
+
+public class ForegroundService extends Service {
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        String action = intent.getAction();
+        if (action != null) {
+            if (action.equals(Constants.ACTION_FOREGROUND_SERVICE_START)) {
+                if(DyteHolder.currActivity!=null) {
+                    NotificationHelper notificationHelper = NotificationHelper.getInstance(DyteHolder.currActivity);
+                    Notification notification = notificationHelper.buildNotification(DyteHolder.currActivity);
+                    if (notification != null) {
+                        try {
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                                startForeground(notificationHelper.NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION | ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA | ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE);
+                            } else {
+                                startForeground(notificationHelper.NOTIFICATION_ID, notification);
+                            }
+                        } catch (RuntimeException e) {
+                            Log.w("ForegroundService", "Failed to start ForegroundService due to: ", e);
+                        }
+                    }
+                }
+
+            } else if (action.equals(Constants.ACTION_FOREGROUND_SERVICE_STOP)) {
+                stopSelf();
+            }
+        }
+        return START_NOT_STICKY;
+
+    }
+}

package/android/src/main/java/com/reactnativecore/NotificationHelper.java

@@ -0,0 +1,127 @@
+package com.reactnativecore;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.util.Log;
+import androidx.core.app.NotificationCompat;
+
+import com.facebook.react.bridge.Promise;
+
+import java.util.Random;
+
+
+class NotificationHelper {
+    public  static final int NOTIFICATION_ID = new Random().nextInt(99999) + 10000;
+    private static final String CHANNEL_ID = "DyteNotificationChannel";
+    private static final String CHANNEL_NAME = "Ongoing Conference Notifications";
+    private static final String CHANNEL_DESC = "Ongoing Conference Notifications";
+
+    private static NotificationHelper instance = null;
+    private NotificationManager mNotificationManager;
+
+    public static synchronized NotificationHelper getInstance(Context context) {
+        if (instance == null) {
+            instance = new NotificationHelper(context);
+        }
+        return instance;
+    }
+
+    private NotificationHelper(Context context) {
+        mNotificationManager = (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);
+
+    }
+
+    void createNotificationChannel(Promise promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            int channelImportance = NotificationManager.IMPORTANCE_DEFAULT;
+            boolean enableVibration = false;
+            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME, channelImportance);
+            channel.setDescription(CHANNEL_DESC);
+            channel.enableVibration(enableVibration);
+            mNotificationManager.createNotificationChannel(channel);
+            promise.resolve(null);
+        } else {
+            promise.reject(Constants.ERROR_ANDROID_VERSION, "DyteForegroundService: Notification channel can be created on Android O+");
+        }
+    }
+
+    Notification buildNotification(Context context) {
+        if (context == null) {
+            return null;
+        }
+        Intent notificationIntent = new Intent(context, context.getClass());
+        PendingIntent pendingIntent;
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+            pendingIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_MUTABLE);
+        }
+        else {
+            pendingIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
+        }
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID);
+        final PackageManager packageManager = context.getPackageManager();
+        int appIconResId = android.R.mipmap.sym_def_app_icon;
+        Bitmap largeIcon = null;
+        try {
+            final ApplicationInfo applicationInfo = packageManager.getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
+            appIconResId=applicationInfo.icon;
+            Drawable drawable=applicationInfo.loadIcon(packageManager);
+            largeIcon = ((BitmapDrawable)drawable).getBitmap();
+        } catch (Exception e) {
+            //pass
+        }
+
+        builder
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setContentTitle("Ongoing Meeting")
+                .setContentText("Tap to return to the meeting")
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                .setContentIntent(pendingIntent)
+                .setOngoing(true)
+                .setWhen(System.currentTimeMillis())
+                .setUsesChronometer(true)
+                .setAutoCancel(false)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setOnlyAlertOnce(true)
+                .setSmallIcon(appIconResId);
+
+        if(largeIcon != null){
+            builder.setLargeIcon(largeIcon);
+        }
+
+        return builder.build();
+    }
+
+    private Class getMainActivityClass(Context context) {
+        String packageName = context.getPackageName();
+        Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(packageName);
+        if (launchIntent == null || launchIntent.getComponent() == null) {
+            // Log.e("NotificationHelper", "Failed to get launch intent or component");
+            return null;
+        }
+        try {
+            return Class.forName(launchIntent.getComponent().getClassName());
+        } catch (ClassNotFoundException e) {
+            // Log.e("NotificationHelper", "Failed to get main activity class");
+            return null;
+        }
+    }
+
+    private int getResourceIdForResourceName(Context context, String resourceName) {
+        int resourceId = context.getResources().getIdentifier(resourceName, "drawable", context.getPackageName());
+        if (resourceId == 0) {
+            resourceId = context.getResources().getIdentifier(resourceName, "mipmap", context.getPackageName());
+        }
+        return resourceId;
+    }
+}

package/android/src/main/java/com/reactnativecore/RNPermissionsModule.java

@@ -0,0 +1,226 @@
+package com.reactnativecore;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.SparseArray;
+import android.os.Process;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.core.PermissionListener;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import java.util.ArrayList;
+
+public class RNPermissionsModule extends ReactContextBaseJavaModule implements PermissionListener {
+
+    private final ReactApplicationContext reactContext;
+
+    private final SparseArray<Request> mRequests = new SparseArray<Request>();
+    private final String GRANTED = "granted";
+    private final String DENIED = "denied";
+    private final String UNAVAILABLE = "unavailable";
+    private final String BLOCKED = "blocked";
+    private final String PROMPTED = "prompted";
+    private int mRequestCode = 0;
+    private static final String ERROR_INVALID_ACTIVITY = "E_INVALID_ACTIVITY";
+
+
+    private class Request {
+
+        public boolean[] rationaleStatuses;
+        public Callback callback;
+
+        public Request(boolean[] rationaleStatuses, Callback callback) {
+            this.rationaleStatuses = rationaleStatuses;
+            this.callback = callback;
+        }
+    }
+
+    public RNPermissionsModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "DyteRNPermissions";
+    }
+
+
+    private @Nullable
+    String getFieldName(final String permission) {
+        if (permission.equals("android.permission.CAMERA"))
+            return "CAMERA";
+        if (permission.equals("android.permission.BLUETOOTH"))
+            return "BLUETOOTH";
+        if (permission.equals("android.permission.BLUETOOTH_CONNECT"))
+            return "BLUETOOTH_CONNECT";
+        if (permission.equals("android.permission.READ_EXTERNAL_STORAGE"))
+            return "READ_EXTERNAL_STORAGE";
+        if (permission.equals("android.permission.READ_PHONE_STATE"))
+            return "READ_PHONE_STATE";
+        if (permission.equals("android.permission.RECORD_AUDIO"))
+            return "RECORD_AUDIO";
+        if (permission.equals("android.permission.USE_SIP"))
+            return "USE_SIP";
+        if (permission.equals("android.permission.WRITE_EXTERNAL_STORAGE"))
+            return "WRITE_EXTERNAL_STORAGE";
+        if (permission.equals("android.permission.ACCESS_FINE_LOCATION"))
+            return "ACCESS_FINE_LOCATION";
+        return null;
+    }
+
+    private boolean permissionExists(final String permission) {
+        String fieldName = getFieldName(permission);
+        if (fieldName == null)
+            return false;
+
+        try {
+            Manifest.permission.class.getField(fieldName);
+            return true;
+        } catch (NoSuchFieldException ignored) {
+            return false;
+        }
+    }
+
+    @ReactMethod
+    public void checkMultiplePermissions(final ReadableArray permissions, final Promise promise) {
+        final WritableMap output = new WritableNativeMap();
+        final ArrayList<String> permissionsToCheck = new ArrayList<String>();
+        int checkedPermissionsCount = 0;
+
+        Context context = getReactApplicationContext().getBaseContext();
+
+        for (int i = 0; i < permissions.size(); i++) {
+            String permission = permissions.getString(i);
+
+            if (!permissionExists(permission)) {
+                output.putString(permission, UNAVAILABLE);
+            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                output.putString(
+                        permission,
+                        context.checkPermission(permission, Process.myPid(), Process.myUid())
+                                == PackageManager.PERMISSION_GRANTED
+                                ? GRANTED
+                                : BLOCKED);
+            } else if (context.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED) {
+                int x = context.checkSelfPermission(permission);
+                output.putString(permission, GRANTED);
+            } else {
+                output.putString(permission, PROMPTED);
+            }
+        }
+
+        promise.resolve(output);
+        return;
+    }
+
+    @ReactMethod
+    public void requestMultiplePermissions(final ReadableArray permissions, boolean entryFlag, final Promise promise) {
+        final WritableMap output = new WritableNativeMap();
+        final ArrayList<String> permissionsToCheck = new ArrayList<String>();
+        int checkedPermissionsCount = 0;
+
+        Context context = getReactApplicationContext().getBaseContext();
+
+        for (int i = 0; i < permissions.size(); i++) {
+            String permission = permissions.getString(i);
+
+            if (!permissionExists(permission)) {
+                output.putString(permission, UNAVAILABLE);
+                checkedPermissionsCount++;
+            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                output.putString(
+                        permission,
+                        context.checkPermission(permission, Process.myPid(), Process.myUid())
+                                == PackageManager.PERMISSION_GRANTED
+                                ? GRANTED
+                                : BLOCKED);
+                checkedPermissionsCount++;
+            } else if (context.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED) {
+                output.putString(permission, GRANTED);
+                checkedPermissionsCount++;
+            } else if (context.checkSelfPermission(permission) == PackageManager.PERMISSION_DENIED) {
+                output.putString(permission, DENIED);
+                permissionsToCheck.add(permission);
+                checkedPermissionsCount++;
+            } else {
+                permissionsToCheck.add(permission);
+            }
+        }
+        if (permissions.size() == checkedPermissionsCount && permissionsToCheck.size() == 0) {
+            promise.resolve(output);
+            return;
+        }
+        try {
+            Activity act = getCurrentActivity();
+            boolean[] rationaleStatuses = new boolean[permissions.size()];
+
+            mRequests.put(mRequestCode, new Request(
+                    rationaleStatuses,
+                    new Callback() {
+                        @Override
+                        public void invoke(Object... args) {
+                            int[] results = (int[]) args[0];
+
+                            for (int j = 0; j < permissionsToCheck.size(); j++) {
+                                String permission = permissionsToCheck.get(j);
+
+                                if (results.length > 0 && results[j] == PackageManager.PERMISSION_GRANTED) {
+                                    output.putString(permission, GRANTED);
+                                } else {
+                                    output.putString(permission, DENIED);
+                                }
+                            }
+                            if(promise != null && output!=null)
+                            promise.resolve(output);
+                        }
+                    }));
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                try {
+                    if (!(act instanceof PermissionAwareActivity)) {
+                        act.requestPermissions(permissionsToCheck.toArray(new String[0]), mRequestCode);
+                    } else {
+                        PermissionAwareActivity ac = (PermissionAwareActivity) act;
+                        ac.requestPermissions(permissionsToCheck.toArray(new String[0]), mRequestCode, this);
+                    }
+                } catch (Error e) {
+                    promise.reject(ERROR_INVALID_ACTIVITY, e);
+                }
+            }
+            mRequestCode++;
+        } catch (Exception e) {
+            promise.reject(ERROR_INVALID_ACTIVITY, e);
+        }
+    }
+
+    public boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        try {
+            if(mRequests == null) {
+                return false;
+            }
+            Request request = mRequests.get(requestCode, null);
+            if(request == null) {
+                return false;
+            }
+            request.callback.invoke(grantResults);
+            mRequests.remove(requestCode);
+            return mRequests.size() == 0;
+        } catch(Exception e) {
+            return false;
+        }
+    }
+}