@quicktvui/ai 1.0.7 → 1.0.9

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/ui/result/PermissionActivityResultHandler.java

@@ -0,0 +1,132 @@
+//package eskit.sdk.core.ui.result;
+//
+//import android.app.Activity;
+//import android.os.Build;
+//import android.support.v4.app.ActivityCompat;
+//import android.util.Pair;
+//
+//import androidx.activity.ComponentActivity;
+//import androidx.activity.result.ActivityResultCallback;
+//import androidx.activity.result.ActivityResultLauncher;
+//import androidx.activity.result.contract.ActivityResultContracts;
+//
+//import com.sunrain.toolkit.utils.log.L;
+//
+//import java.util.ArrayList;
+//import java.util.Arrays;
+//import java.util.Collections;
+//import java.util.List;
+//
+//import eskit.sdk.core.internal.EsViewManager;
+//import eskit.sdk.core.internal.EsContext;
+//import com.quicktvui.sdk.base.EsCallback;
+//
+///**
+// * 权限申请
+// * <p>
+// * Create by weipeng on 2022/09/09 10:01
+// */
+//public class PermissionActivityResultHandler implements ActivityResultCallback<Boolean> {
+//
+//    private final ActivityResultLauncher<String> mRequestPermissionResult;
+//    private Requester mRequester;
+//
+//    public PermissionActivityResultHandler(ComponentActivity activity) {
+//        ActivityCompat.setPermissionCompatDelegate();
+//        mRequestPermissionResult = activity.registerForActivityResult(
+//                new ActivityResultContracts.RequestPermission(), this);
+//    }
+//
+//    @Override
+//    public void onActivityResult(Boolean isGranted) {
+//        if (L.DEBUG)
+//            L.logD("requestPermission permissions: " + isGranted);
+//        if (mRequester == null) return;
+//        mRequester.onActivityResult(isGranted);
+//    }
+//
+//    public void requestPermission(String[] permissions, EsCallback<List<String>, Pair<List<String>, List<String>>> callback) {
+//        if (permissions == null || permissions.length == 0) {
+//            callback.onSuccess(Collections.emptyList());
+//            return;
+//        }
+//        mRequester = new Requester(mRequestPermissionResult, permissions, callback);
+//        mRequester.requestNext();
+//    }
+//
+//    private static final class Requester {
+//
+//        private ActivityResultLauncher<String> permissionResult;
+//        private List<String> permissions;
+//        private EsCallback<List<String>, Pair<List<String>, List<String>>> callback;
+//
+//        private List<String> granted;
+//        private List<String> never;
+//        private List<String> denied;
+//
+//        private String currentRequest;
+//
+//        public Requester(ActivityResultLauncher<String> permissionResult, String[] permissions, EsCallback<List<String>, Pair<List<String>, List<String>>> callback) {
+//            this.permissionResult = permissionResult;
+//            this.permissions = new ArrayList<>(Arrays.asList(permissions));
+//            this.callback = callback;
+//
+//            this.granted = new ArrayList<>(permissions.length);
+//            this.never = new ArrayList<>(permissions.length);
+//            this.denied = new ArrayList<>(permissions.length);
+//        }
+//
+//        private void requestNext() {
+//            if (permissions == null || permissions.size() == 0) {
+//                try {
+//                    if (this.denied.size() != 0 || this.never.size() != 0) {
+//                        callback.onFailed(new Pair<>(never, denied));
+//                    } else {
+//                        callback.onSuccess(granted);
+//                    }
+//                } catch (Exception e) {
+//                    e.printStackTrace();
+//                }
+//                release();
+//                return;
+//            }
+//            currentRequest = permissions.get(0);
+//            permissions.remove(0);
+//            permissionResult.launch(currentRequest);
+//        }
+//
+//        public void onActivityResult(Boolean isGranted) {
+//            if (isGranted) {
+//                this.granted.add(currentRequest);
+//            } else {
+//                this.denied.add(currentRequest);
+//                EsViewManager vm = EsViewManager.get();
+//                if (vm != null) {
+//                    Activity activity = vm.getTopActivity();
+//                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+//                        if (activity != null && !activity.shouldShowRequestPermissionRationale(currentRequest)) {
+//                            never.add(currentRequest);
+//                            this.denied.remove(currentRequest);
+//                        }
+//                    }
+//                }
+//            }
+//            permissions.remove(currentRequest);
+//            requestNext();
+//        }
+//
+//        private void release() {
+//            permissions.clear();
+//            permissions = null;
+//            permissionResult = null;
+//            callback = null;
+//            granted.clear();
+//            granted = null;
+//            denied.clear();
+//            denied = null;
+//            never.clear();
+//            never = null;
+//            currentRequest = null;
+//        }
+//    }
+//}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/ui/wm/AbstractWindowManager.java

@@ -0,0 +1,120 @@
+package com.quicktvui.sdk.core.ui.wm;
+
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.PixelFormat;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+import android.util.DisplayMetrics;
+import android.view.View;
+import android.view.WindowManager;
+
+import com.sunrain.toolkit.utils.log.L;
+
+/**
+ * @author WeiPeng
+ * @version 1.0
+ * @title AbstractWindowManager.java
+ * @created 2019/08/20 11:33
+ */
+public abstract class AbstractWindowManager {
+
+    protected Context context;
+
+    private WindowManager mWindowManager;
+    private WindowManager.LayoutParams mParams;
+    private View mMainView;
+    protected boolean mShown = false;
+
+    public static void requestPermission(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (Settings.canDrawOverlays(context)) return;
+            Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
+            intent.setData(Uri.parse("package:" + context.getPackageName()));
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            context.startActivity(intent);
+        }
+    }
+
+    public AbstractWindowManager(Context ctx) {
+        context = ctx.getApplicationContext();
+        mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+        mParams = new WindowManager.LayoutParams();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            mParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+        } else {
+            mParams.type = WindowManager.LayoutParams.TYPE_APPLICATION;
+        }
+
+        mParams.format = PixelFormat.RGBA_8888;
+        mParams.width = WindowManager.LayoutParams.MATCH_PARENT;
+        mParams.height = WindowManager.LayoutParams.MATCH_PARENT;
+
+        configWindowManagerLayoutParams(mParams);
+    }
+
+    protected void hasFocus(WindowManager.LayoutParams params) {
+        int flags = WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
+        flags = flags | WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
+        params.flags = params.flags | flags;
+    }
+
+    protected void noFocus(WindowManager.LayoutParams params) {
+        int flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
+        flags = flags | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
+        flags = flags | WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
+        params.flags = params.flags | flags;
+    }
+
+    public WindowManager.LayoutParams getWindowParams() {
+        return mParams;
+    }
+
+    protected boolean addView(View view) {
+        try {
+            mWindowManager.addView(view, mParams);
+            mMainView = view;
+            mShown = true;
+            return true;
+        } catch (Exception e) {
+            L.logW("wm add view", e);
+        }
+        return false;
+    }
+
+    protected boolean removeView() {
+        return removeView(mMainView);
+    }
+
+    protected boolean removeView(View view) {
+        try {
+            if (view != null) {
+                mWindowManager.removeViewImmediate(view);
+                mMainView = null;
+                mShown = false;
+                return true;
+            }
+        } catch (Exception e) {
+            L.logW("wm rm view", e);
+        }
+        return false;
+    }
+
+    protected <T extends View> T getView(int resId) {
+        return (T) mMainView.findViewById(resId);
+    }
+
+    protected DisplayMetrics getDisplayMetrics() {
+        DisplayMetrics dm = new DisplayMetrics();
+        mWindowManager.getDefaultDisplay().getMetrics(dm);
+        return dm;
+    }
+
+    protected abstract void configWindowManagerLayoutParams(WindowManager.LayoutParams params);
+
+    public boolean isShown() {
+        return mShown;
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/Am.java

@@ -0,0 +1,397 @@
+package com.quicktvui.sdk.core.utils;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.TextUtils;
+
+import com.sunrain.toolkit.utils.log.L;
+
+import java.net.URISyntaxException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import com.quicktvui.sdk.base.EsException;
+
+public class Am {
+
+    public static final String TYPE_ACTIVITY = "start";
+    public static final String TYPE_BROADCAST = "broadcast";
+    public static final String TYPE_SERVICE = "startservice";
+
+    private static final byte TYPE_ACTIVITY_INT = 0;
+    private static final byte TYPE_BROADCAST_INT = 1;
+    private static final byte TYPE_SERVICE_INT = 2;
+
+    private String[] mArgs;
+    private int mNextArg;
+    private String mCurArgData;
+    private byte mCurrentType = -1;
+
+    public EsIntent makeIntent(String cmd) throws Exception {
+        try {
+            int amIndex = cmd.indexOf("am ");
+            if (amIndex < 0) {
+                throw new EsException("cmd not found 'am'");
+            }
+            cmd = Pattern.compile("\\s+").matcher(cmd).replaceAll(" ");
+            String cutAm = cmd.substring(amIndex + 3);
+            mArgs = cutAm.split(" ");
+            mNextArg = 1;
+            makeIntentType(mArgs[0]);
+            return makeIntent();
+        } catch (Throwable e) {
+            reset();
+            L.logW("am make intent", e);
+            throw e;
+        }
+    }
+
+    public EsIntent makeIntent(String type, List<String[]> cmd) throws Exception {
+        makeArgs(cmd);
+        makeIntentType(type);
+        return makeIntent();
+    }
+
+    public void execute(Context context, EsIntent intent) throws Exception {
+        try {
+            switch (mCurrentType) {
+                case TYPE_ACTIVITY_INT:
+                    context.startActivity(intent);
+                    break;
+                case TYPE_BROADCAST_INT:
+                    context.sendBroadcast(intent);
+                    break;
+                case TYPE_SERVICE_INT:
+                    if (intent.hasCustomFlag(EsIntent.FLAG_FOREGROUND_SERVICE)) { // 需要启动前台服务
+                        L.logIF("startForegroundService");
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                            context.startForegroundService(intent);
+                            break;
+                        }
+                    }
+                    context.startService(intent);
+                    break;
+                default:
+                    break;
+            }
+        } finally {
+            reset();
+        }
+    }
+
+    private void makeArgs(List<String[]> cmd) {
+        int size = 0;
+        for (String[] line : cmd) {
+            size += line.length;
+        }
+
+        mArgs = new String[size];
+        int index = 0;
+        for (String[] line : cmd) {
+            for (String opt : line) {
+                mArgs[index++] = opt;
+            }
+        }
+    }
+
+    private void makeIntentType(String type) {
+        switch (type) {
+            case TYPE_ACTIVITY:
+                mCurrentType = TYPE_ACTIVITY_INT;
+                break;
+            case TYPE_BROADCAST:
+                mCurrentType = TYPE_BROADCAST_INT;
+                break;
+            case TYPE_SERVICE:
+                mCurrentType = TYPE_SERVICE_INT;
+                break;
+            default:
+                throw new EsException(-1, "not support cmd type :" + type);
+        }
+    }
+
+    private void reset() {
+        mArgs = null;
+        mCurArgData = null;
+        mNextArg = 0;
+        mCurrentType = -1;
+    }
+
+    private EsIntent makeIntent() throws URISyntaxException {
+        EsIntent intent = new EsIntent();
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        EsIntent baseIntent = intent;
+        boolean hasIntentInfo = false;
+        Uri data = null;
+        String type = null;
+        String opt;
+        while ((opt = nextOption()) != null) {
+            if (opt.equals("-a")) {
+                intent.setAction(nextArgRequired());
+                if (intent == baseIntent) {
+                    hasIntentInfo = true;
+                }
+            } else if (opt.equals("-p")) {
+                String pkg = nextArgRequired();
+                if (!TextUtils.isEmpty(pkg)) {
+                    intent.setPackage(pkg);
+                }
+                if (intent == baseIntent) {
+                    hasIntentInfo = true;
+                }
+            } else if (opt.equals("-d")) {
+                data = Uri.parse(nextArgRequired());
+                if (intent == baseIntent) {
+                    hasIntentInfo = true;
+                }
+            } else if (opt.equals("-t")) {
+                type = nextArgRequired();
+                if (intent == baseIntent) {
+                    hasIntentInfo = true;
+                }
+            } else if (opt.equals("-c")) {
+                intent.addCategory(nextArgRequired());
+                if (intent == baseIntent) {
+                    hasIntentInfo = true;
+                }
+            } else if (opt.equals("-e") || opt.equals("--es")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                intent.putExtra(key, value);
+            } else if (opt.equals("--esn")) {
+                String key = nextArgRequired();
+                intent.putExtra(key, (String) null);
+            } else if (opt.equals("--ei")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                intent.putExtra(key, Integer.valueOf(value));
+            } else if (opt.equals("--eu")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                intent.putExtra(key, Uri.parse(value));
+            } else if (opt.equals("--eia")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                String[] strings = value.split(",");
+                int[] list = new int[strings.length];
+                for (int i = 0; i < strings.length; i++) {
+                    list[i] = Integer.valueOf(strings[i]);
+                }
+                intent.putExtra(key, list);
+            } else if (opt.equals("--el")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                intent.putExtra(key, Long.valueOf(value));
+            } else if (opt.equals("--ela")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                String[] strings = value.split(",");
+                long[] list = new long[strings.length];
+                for (int i = 0; i < strings.length; i++) {
+                    list[i] = Long.valueOf(strings[i]);
+                }
+                intent.putExtra(key, list);
+            } else if (opt.equals("--ez")) {
+                String key = nextArgRequired();
+                String value = nextArgRequired();
+                intent.putExtra(key, Boolean.valueOf(value));
+            } else if (opt.equals("-n")) {
+                String str = nextArgRequired();
+                ComponentName cn = ComponentName.unflattenFromString(str);
+                if (cn == null) throw new IllegalArgumentException("Bad component name: " + str);
+                intent.setComponent(cn);
+                if (intent == baseIntent) {
+                    hasIntentInfo = true;
+                }
+            } else if (opt.equals("-f")) {
+                String str = nextArgRequired();
+                intent.setFlags(Integer.decode(str).intValue());
+            } else if (opt.equals("--grant-read-uri-permission")) {
+                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+            } else if (opt.equals("--grant-write-uri-permission")) {
+                intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+            } else if (opt.equals("--exclude-stopped-packages")) {
+                intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);
+            } else if (opt.equals("--include-stopped-packages")) {
+                intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
+            } else if (opt.equals("--debug-log-resolution")) {
+                intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION);
+            } else if (opt.equals("--activity-brought-to-front")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
+            } else if (opt.equals("--activity-clear-top")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            } else if (opt.equals("--activity-clear-when-task-reset")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
+            } else if (opt.equals("--activity-exclude-from-recents")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+            } else if (opt.equals("--activity-launched-from-history")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY);
+            } else if (opt.equals("--activity-multiple-task")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+            } else if (opt.equals("--activity-no-animation")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
+            } else if (opt.equals("--activity-no-history")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
+            } else if (opt.equals("--activity-no-user-action")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION);
+            } else if (opt.equals("--activity-previous-is-top")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP);
+            } else if (opt.equals("--activity-reorder-to-front")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
+            } else if (opt.equals("--activity-reset-task-if-needed")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
+            } else if (opt.equals("--activity-single-top")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+            } else if (opt.equals("--activity-clear-task")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
+            } else if (opt.equals("--activity-task-on-home")) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_TASK_ON_HOME);
+            } else if (opt.equals("--receiver-registered-only")) {
+                intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
+            } else if (opt.equals("--receiver-replace-pending")) {
+                intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
+            } else if (opt.equals("--foreground-service")) {
+                L.logIF("addCustomFlag");
+                intent.addCustomFlag(EsIntent.FLAG_FOREGROUND_SERVICE);
+            } else if (opt.equals("--selector")) {
+                intent.setDataAndType(data, type);
+                intent = new EsIntent();
+            }
+//      else if (opt.equals("-D")) {
+//        mDebugOption = true;
+//      } else if (opt.equals("-W")) {
+//        mWaitOption = true;
+//      } else if (opt.equals("-P")) {
+//        mProfileFile = nextArgRequired();
+//        mProfileAutoStop = true;
+//      } else if (opt.equals("--start-profiler")) {
+//        mProfileFile = nextArgRequired();
+//        mProfileAutoStop = false;
+//      } else if (opt.equals("-R")) {
+//        mRepeat = Integer.parseInt(nextArgRequired());
+//      } else if (opt.equals("-S")) {
+//        mStopOption = true;
+//      }
+            else {
+                System.err.println("Error: Unknown option: " + opt);
+//                return null;
+            }
+        }
+        intent.setDataAndType(data, type);
+        final boolean hasSelector = intent != baseIntent;
+        if (hasSelector) {
+            // A selector was specified; fix up.
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
+                baseIntent.setSelector(intent);
+            }
+            intent = baseIntent;
+        }
+        String arg = nextArg();
+        baseIntent = null;
+        if (arg == null) {
+            if (hasSelector) {
+                // If a selector has been specified, and no arguments
+                // have been supplied for the main Intent, then we can
+                // assume it is ACTION_MAIN CATEGORY_LAUNCHER; we don't
+                // need to have a component name specified yet, the
+                // selector will take care of that.
+                baseIntent = new EsIntent(Intent.ACTION_MAIN);
+                baseIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+            }
+        } else if (arg.indexOf(':') >= 0) {
+            // The argument is a URI.  Fully parse it, and use that result
+            // to fill in any data not specified so far.
+            baseIntent = EsIntent.parseUri(arg, Intent.URI_INTENT_SCHEME);
+        } else if (arg.indexOf('/') >= 0) {
+            // The argument is a component name.  Build an Intent to launch
+            // it.
+            baseIntent = new EsIntent(Intent.ACTION_MAIN);
+            baseIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+            baseIntent.setComponent(ComponentName.unflattenFromString(arg));
+        } else {
+            // Assume the argument is a package name.
+            baseIntent = new EsIntent(Intent.ACTION_MAIN);
+            baseIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+            baseIntent.setPackage(arg);
+        }
+        if (baseIntent != null) {
+            Bundle extras = intent.getExtras();
+            intent.replaceExtras((Bundle) null);
+            Bundle uriExtras = baseIntent.getExtras();
+            baseIntent.replaceExtras((Bundle) null);
+            if (intent.getAction() != null && baseIntent.getCategories() != null) {
+                HashSet<String> cats = new HashSet<String>(baseIntent.getCategories());
+                for (String c : cats) {
+                    baseIntent.removeCategory(c);
+                }
+            }
+            intent.fillIn(baseIntent, Intent.FILL_IN_COMPONENT | Intent.FILL_IN_SELECTOR);
+            if (extras == null) {
+                extras = uriExtras;
+            } else if (uriExtras != null) {
+                uriExtras.putAll(extras);
+                extras = uriExtras;
+            }
+            intent.replaceExtras(extras);
+            hasIntentInfo = true;
+        }
+        if (!hasIntentInfo) throw new IllegalArgumentException("No intent supplied");
+        return intent;
+    }
+
+    private String nextOption() {
+        if (mCurArgData != null) {
+            String prev = mArgs[mNextArg - 1];
+            throw new IllegalArgumentException("No argument expected after \"" + prev + "\"");
+        }
+        if (mNextArg >= mArgs.length) {
+            return null;
+        }
+        String arg = mArgs[mNextArg];
+        if (!arg.startsWith("-")) {
+            return null;
+        }
+        mNextArg++;
+        if (arg.equals("--")) {
+            return null;
+        }
+        if (arg.length() > 1 && arg.charAt(1) != '-') {
+            if (arg.length() > 2) {
+                mCurArgData = arg.substring(2);
+                return arg.substring(0, 2);
+            } else {
+                mCurArgData = null;
+                return arg;
+            }
+        }
+        mCurArgData = null;
+        return arg;
+    }
+
+    private String nextArg() {
+        if (mCurArgData != null) {
+            String arg = mCurArgData;
+            mCurArgData = null;
+            return arg;
+        } else if (mNextArg < mArgs.length) {
+            return mArgs[mNextArg++];
+        } else {
+            return null;
+        }
+    }
+
+    private String nextArgRequired() {
+        String arg = nextArg();
+        if (arg == null) {
+            String prev = mArgs[mNextArg - 1];
+            throw new IllegalArgumentException("Argument expected after \"" + prev + "\"");
+        }
+        return arg;
+    }
+
+}