@capgo/inappbrowser 0.0.1

package/CapgoInappbrowser.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoInappbrowser'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '12.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,118 @@
+# @capgo/inappbrowser
+
+Capacitor plugin in app browser
+
+## Install
+
+```bash
+npm install @capgo/inappbrowser
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`open(...)`](#open)
+* [`close()`](#close)
+* [`openWebView(...)`](#openwebview)
+* [Interfaces](#interfaces)
+* [Enums](#enums)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### open(...)
+
+```typescript
+open(options: OpenOptions) => Promise<any>
+```
+
+| Param         | Type                                                |
+| ------------- | --------------------------------------------------- |
+| **`options`** | <code><a href="#openoptions">OpenOptions</a></code> |
+
+**Returns:** <code>Promise&lt;any&gt;</code>
+
+--------------------
+
+
+### close()
+
+```typescript
+close() => Promise<any>
+```
+
+**Returns:** <code>Promise&lt;any&gt;</code>
+
+--------------------
+
+
+### openWebView(...)
+
+```typescript
+openWebView(options: OpenWebViewOptions) => Promise<any>
+```
+
+| Param         | Type                                                              |
+| ------------- | ----------------------------------------------------------------- |
+| **`options`** | <code><a href="#openwebviewoptions">OpenWebViewOptions</a></code> |
+
+**Returns:** <code>Promise&lt;any&gt;</code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### OpenOptions
+
+| Prop                         | Type                                        |
+| ---------------------------- | ------------------------------------------- |
+| **`url`**                    | <code>string</code>                         |
+| **`headers`**                | <code><a href="#headers">Headers</a></code> |
+| **`isPresentAfterPageLoad`** | <code>boolean</code>                        |
+
+
+#### Headers
+
+
+#### OpenWebViewOptions
+
+| Prop                         | Type                                                            |
+| ---------------------------- | --------------------------------------------------------------- |
+| **`url`**                    | <code>string</code>                                             |
+| **`headers`**                | <code><a href="#headers">Headers</a></code>                     |
+| **`shareDisclaimer`**        | <code><a href="#disclaimeroptions">DisclaimerOptions</a></code> |
+| **`toolbarType`**            | <code><a href="#toolbartype">ToolBarType</a></code>             |
+| **`shareSubject`**           | <code>string</code>                                             |
+| **`title`**                  | <code>string</code>                                             |
+| **`isPresentAfterPageLoad`** | <code>boolean</code>                                            |
+
+
+#### DisclaimerOptions
+
+| Prop             | Type                |
+| ---------------- | ------------------- |
+| **`title`**      | <code>string</code> |
+| **`message`**    | <code>string</code> |
+| **`confirmBtn`** | <code>string</code> |
+| **`cancelBtn`**  | <code>string</code> |
+
+
+### Enums
+
+
+#### ToolBarType
+
+| Members          | Value                     |
+| ---------------- | ------------------------- |
+| **`ACTIVITY`**   | <code>"activity"</code>   |
+| **`NAVIGATION`** | <code>"navigation"</code> |
+| **`BLANK`**      | <code>"blank"</code>      |
+| **`DEFAULT`**    | <code>""</code>           |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.1'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.2.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.2'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.3.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 30
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 21
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 30
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    jcenter()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="ee.forgr.capacitor_inappbrowser">
+</manifest>

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/InAppBrowserPlugin.java

@@ -0,0 +1,160 @@
+package ee.forgr.capacitor_inappbrowser;
+
+import android.content.ComponentName;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.customtabs.CustomTabsCallback;
+import android.support.customtabs.CustomTabsClient;
+import android.support.customtabs.CustomTabsIntent;
+import android.support.customtabs.CustomTabsServiceConnection;
+import android.support.customtabs.CustomTabsSession;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.NativePlugin;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+
+import java.util.Iterator;
+
+@NativePlugin()
+public class CapBrowser extends Plugin {
+    public static final String CUSTOM_TAB_PACKAGE_NAME = "com.android.chrome";  // Change when in stable
+    private CustomTabsClient customTabsClient;
+    private CustomTabsSession currentSession;
+    private WebViewDialog webViewDialog = null;
+
+    CustomTabsServiceConnection connection = new CustomTabsServiceConnection() {
+        @Override
+        public void onCustomTabsServiceConnected(ComponentName name, CustomTabsClient client) {
+            customTabsClient = client;
+            client.warmup(0);
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+        }
+    };
+
+    @PluginMethod()
+    public void open(PluginCall call) {
+        String url = call.getString("url");
+        if(url == null || TextUtils.isEmpty(url)) {
+            call.error("Invalid URL");
+        }
+        CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder(getCustomTabsSession());
+        builder.addDefaultShareMenuItem();
+        CustomTabsIntent tabsIntent = builder.build();
+        tabsIntent.intent.putExtra(Intent.EXTRA_REFERRER,
+                Uri.parse(Intent.URI_ANDROID_APP_SCHEME + "//" + getContext().getPackageName()));
+        tabsIntent.intent.putExtra(android.provider.Browser.EXTRA_HEADERS, this.getHeaders(call));
+        tabsIntent.launchUrl(getContext(), Uri.parse(url));
+
+        call.success();
+    }
+
+    @PluginMethod()
+    public void openWebView(PluginCall call) {
+        String url = call.getString("url");
+        if(url == null || TextUtils.isEmpty(url)) {
+            call.error("Invalid URL");
+        }
+        final Options options = new Options();
+        options.setUrl(url);
+        options.setHeaders(call.getObject("headers"));
+        options.setTitle(call.getString("title", "New Window"));
+        options.setShareDisclaimer(call.getObject("shareDisclaimer", null));
+        options.setShareSubject(call.getString("shareSubject", null));
+        options.setToolbarType(call.getString("toolbarType", ""));
+        options.setPresentAfterPageLoad(call.getBoolean("isPresentAfterPageLoad", false));
+        options.setPluginCall(call);
+        options.setCallbacks(new WebViewCallbacks() {
+            @Override
+            public void urlChangeEvent(String url) {
+                notifyListeners("urlChangeEvent", new JSObject().put("url", url));
+            }
+
+            @Override
+            public void pageLoaded() {
+                notifyListeners("browserPageLoaded", new JSObject());
+            }
+
+            @Override
+            public void pageLoadError() {
+                notifyListeners("pageLoadError", new JSObject());
+            }
+        });
+        getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                webViewDialog = new WebViewDialog(getContext(), android.R.style.Theme_NoTitleBar, options);
+                webViewDialog.presentWebView();
+            }
+        });
+    }
+
+    @PluginMethod()
+    public void close(PluginCall call) {
+        if (webViewDialog != null) {
+            webViewDialog.dismiss();
+            webViewDialog = null;
+        } else {
+            Intent intent = new Intent(getContext(), getBridge().getActivity().getClass());
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            getContext().startActivity(intent);
+        }
+        call.success();
+    }
+
+    private Bundle getHeaders(PluginCall pluginCall) {
+        JSObject headersProvided = pluginCall.getObject("headers");
+        Bundle headers = new Bundle();
+        if(headersProvided != null) {
+            Iterator<String> keys = headersProvided.keys();
+            while(keys.hasNext()) {
+                String key = keys.next();
+                headers.putString(key, headersProvided.getString(key));
+            }
+        }
+        return headers;
+    }
+
+    protected void handleOnResume() {
+        boolean ok = CustomTabsClient.bindCustomTabsService(getContext(), CUSTOM_TAB_PACKAGE_NAME, connection);
+        if (!ok) {
+            Log.e(getLogTag(), "Error binding to custom tabs service");
+        }
+    }
+
+    protected void handleOnPause() {
+        getContext().unbindService(connection);
+    }
+
+    public CustomTabsSession getCustomTabsSession() {
+        if (customTabsClient == null) {
+            return null;
+        }
+
+        if (currentSession == null) {
+            currentSession = customTabsClient.newSession(new CustomTabsCallback(){
+                @Override
+                public void onNavigationEvent(int navigationEvent, Bundle extras) {
+                    switch (navigationEvent) {
+                        case NAVIGATION_FINISHED:
+                            notifyListeners("browserPageLoaded", new JSObject());
+                            break;
+                    }
+                }
+            });
+        }
+        return currentSession;
+    }
+
+    @Override
+    protected void handleOnActivityResult(int requestCode, int resultCode, Intent data) {
+        super.handleOnActivityResult(requestCode, resultCode, data);
+    }
+}

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/Options.java

@@ -0,0 +1,88 @@
+package ee.forgr.capacitor_inappbrowser;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+
+public class Options {
+    private String title;
+    private String url;
+    private JSObject headers;
+    private String toolbarType;
+    private JSObject shareDisclaimer;
+    private String shareSubject;
+    private boolean isPresentAfterPageLoad;
+    private WebViewCallbacks callbacks;
+    private PluginCall pluginCall;
+
+    public PluginCall getPluginCall() {
+        return pluginCall;
+    }
+
+    public void setPluginCall(PluginCall pluginCall) {
+        this.pluginCall = pluginCall;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public JSObject getHeaders() {
+        return headers;
+    }
+
+    public void setHeaders(JSObject headers) {
+        this.headers = headers;
+    }
+
+    public String getToolbarType() {
+        return toolbarType;
+    }
+
+    public void setToolbarType(String toolbarType) {
+        this.toolbarType = toolbarType;
+    }
+
+    public JSObject getShareDisclaimer() {
+        return shareDisclaimer;
+    }
+
+    public void setShareDisclaimer(JSObject shareDisclaimer) {
+        this.shareDisclaimer = shareDisclaimer;
+    }
+
+    public String getShareSubject() {
+        return shareSubject;
+    }
+
+    public void setShareSubject(String shareSubject) {
+        this.shareSubject = shareSubject;
+    }
+
+    public boolean isPresentAfterPageLoad() {
+        return isPresentAfterPageLoad;
+    }
+
+    public void setPresentAfterPageLoad(boolean presentAfterPageLoad) {
+        isPresentAfterPageLoad = presentAfterPageLoad;
+    }
+
+    public WebViewCallbacks getCallbacks() {
+        return callbacks;
+    }
+
+    public void setCallbacks(WebViewCallbacks callbacks) {
+        this.callbacks = callbacks;
+    }
+}

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/WebViewCallbacks.java

@@ -0,0 +1,7 @@
+package ee.forgr.capacitor_inappbrowser;
+
+public interface WebViewCallbacks {
+    public void urlChangeEvent(String url);
+    public void pageLoaded();
+    public void pageLoadError();
+}

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/WebViewDialog.java

@@ -0,0 +1,218 @@
+package ee.forgr.capacitor_inappbrowser;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.support.v7.widget.Toolbar;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.webkit.WebResourceError;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.ImageButton;
+import android.widget.TextView;
+
+import com.cap.browser.plugin.capbrowser.R;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public class WebViewDialog extends Dialog {
+    private WebView _webView;
+    private Toolbar _toolbar;
+    private Options _options;
+    private boolean isInitialized = false;
+
+    public WebViewDialog(Context context, int theme, Options options) {
+        super(context, theme);
+        this._options = options;
+        this.isInitialized = false;
+    }
+
+    public void presentWebView() {
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setCancelable(true);
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+        setContentView(R.layout.activity_browser);
+        getWindow().setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT);
+
+        this._webView = findViewById(R.id.browser_view);
+
+        _webView.getSettings().setJavaScriptEnabled(true);
+        _webView.getSettings().setJavaScriptCanOpenWindowsAutomatically(true);
+        _webView.getSettings().setDatabaseEnabled(true);
+        _webView.getSettings().setDomStorageEnabled(true);
+        _webView.getSettings().setPluginState(android.webkit.WebSettings.PluginState.ON);
+        _webView.getSettings().setLoadWithOverviewMode(true);
+        _webView.getSettings().setUseWideViewPort(true);
+
+        Map<String, String> requestHeaders = new HashMap<>();
+        if(_options.getHeaders() != null) {
+            Iterator<String> keys = _options.getHeaders().keys();
+            while(keys.hasNext()) {
+                String key = keys.next();
+                if(TextUtils.equals(key, "User-Agent")) {
+                    _webView.getSettings().setUserAgentString(_options.getHeaders().getString(key));
+                } else {
+                    requestHeaders.put(key, _options.getHeaders().getString(key));
+                }
+            }
+        }
+
+        _webView.loadUrl(this._options.getUrl(), requestHeaders);
+        _webView.requestFocus();
+        _webView.requestFocusFromTouch();
+
+        setupToolbar();
+        setWebViewClient();
+
+        if(!this._options.isPresentAfterPageLoad()) {
+            show();
+            _options.getPluginCall().success();
+        }
+    }
+
+    private void setTitle(String newTitleText) {
+        TextView textView = (TextView) _toolbar.findViewById(R.id.titleText);
+        textView.setText(newTitleText);
+    }
+
+    private void setupToolbar() {
+        _toolbar = this.findViewById(R.id.tool_bar);
+        if(!TextUtils.isEmpty(_options.getTitle())) {
+            this.setTitle(_options.getTitle());
+        } else {
+            try {
+                URI uri = new URI(_options.getUrl());
+                this.setTitle(uri.getHost());
+            } catch (URISyntaxException e) {
+                this.setTitle(_options.getTitle());
+            }
+        }
+
+        View backButton = _toolbar.findViewById(R.id.backButton);
+        backButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                if(_webView.canGoBack()) {
+                    _webView.goBack();
+                }
+            }
+        });
+
+        View forwardButton = _toolbar.findViewById(R.id.forwardButton);
+        forwardButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                if(_webView.canGoForward()) {
+                    _webView.goForward();
+                }
+            }
+        });
+
+        View closeButton = _toolbar.findViewById(R.id.closeButton);
+        closeButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                dismiss();
+            }
+        });
+
+        if(TextUtils.equals(_options.getToolbarType(), "activity")) {
+            _toolbar.findViewById(R.id.forwardButton).setVisibility(View.GONE);
+            _toolbar.findViewById(R.id.backButton).setVisibility(View.GONE);
+            //TODO: Add share button functionality
+        } else if(TextUtils.equals(_options.getToolbarType(), "navigation")) {
+            //TODO: Remove share button when implemented
+        } else if(TextUtils.equals(_options.getToolbarType(), "blank")){
+            _toolbar.setVisibility(View.GONE);
+        } else {
+            _toolbar.findViewById(R.id.forwardButton).setVisibility(View.GONE);
+            _toolbar.findViewById(R.id.backButton).setVisibility(View.GONE);
+        }
+    }
+
+    private void setWebViewClient() {
+        _webView.setWebViewClient(new WebViewClient() {
+
+            @Override
+            public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
+                return false;
+            }
+
+            @Override
+            public void onLoadResource(WebView view, String url) {
+                super.onLoadResource(view, url);
+            }
+
+            @Override
+            public void onPageStarted(WebView view, String url, Bitmap favicon) {
+                super.onPageStarted(view, url, favicon);
+                try {
+                    URI uri = new URI(url);
+                    setTitle(uri.getHost());
+                } catch (URISyntaxException e) {
+                    // Do nothing
+                }
+                _options.getCallbacks().urlChangeEvent(url);
+            }
+
+            @Override
+            public void onPageFinished(WebView view, String url) {
+                super.onPageFinished(view, url);
+                _options.getCallbacks().pageLoaded();
+                if(!isInitialized) {
+                    isInitialized = true;
+                    _webView.clearHistory();
+                    if(_options.isPresentAfterPageLoad()) {
+                        show();
+                        _options.getPluginCall().success();
+                    }
+                }
+
+                ImageButton backButton = _toolbar.findViewById(R.id.backButton);
+                if(_webView.canGoBack()) {
+                    backButton.setImageResource(R.drawable.arrow_back_enabled);
+                    backButton.setEnabled(true);
+                } else {
+                    backButton.setImageResource(R.drawable.arrow_back_disabled);
+                    backButton.setEnabled(false);
+                }
+
+                ImageButton forwardButton = _toolbar.findViewById(R.id.forwardButton);
+                if(_webView.canGoForward()) {
+                    forwardButton.setImageResource(R.drawable.arrow_forward_enabled);
+                    forwardButton.setEnabled(true);
+                } else {
+                    forwardButton.setImageResource(R.drawable.arrow_forward_disabled);
+                    forwardButton.setEnabled(false);
+                }
+
+                _options.getCallbacks().pageLoaded();
+            }
+
+            @Override
+            public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
+                super.onReceivedError(view, request, error);
+                _options.getCallbacks().pageLoadError();
+            }
+        });
+    }
+
+
+
+    @Override
+    public void onBackPressed() {
+        if(_webView.canGoBack() && TextUtils.equals(_options.getToolbarType(), "navigation")) {
+            _webView.goBack();
+        } else {
+            super.onBackPressed();
+        }
+    }
+}

package/android/src/main/res/drawable/arrow_back_disabled.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:fillColor="@color/disable"
+      android:pathData="M11.67,3.87L9.9,2.1 0,12l9.9,9.9 1.77,-1.77L3.54,12z"/>
+</vector>

package/android/src/main/res/drawable/arrow_back_enabled.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:fillColor="@color/enable"
+      android:pathData="M11.67,3.87L9.9,2.1 0,12l9.9,9.9 1.77,-1.77L3.54,12z"/>
+</vector>