void OpenCustomTab()
        {
            string url = mUrlEditText.Text;

            int color          = GetColor(mCustomTabColorEditText);
            int secondaryColor = GetColor(mCustomTabSecondaryColorEditText);

            CustomTabsIntent.Builder intentBuilder = new CustomTabsIntent.Builder();
            intentBuilder.SetToolbarColor(color);
            intentBuilder.SetSecondaryToolbarColor(secondaryColor);

            if (mShowActionButtonCheckbox.Checked)
            {
                //Generally you do not want to decode bitmaps in the UI thread. Decoding it in the
                //UI thread to keep the example short.
                string        actionLabel   = GetString(Resource.String.label_action);
                Bitmap        icon          = BitmapFactory.DecodeResource(Resources, Android.Resource.Drawable.IcMenuShare);
                PendingIntent pendingIntent = CreatePendingIntent(ActionBroadcastReceiver.ACTION_ACTION_BUTTON);
                intentBuilder.SetActionButton(icon, actionLabel, pendingIntent);
            }

            if (mAddMenusCheckbox.Checked)
            {
                string        menuItemTitle         = GetString(Resource.String.menu_item_title);
                PendingIntent menuItemPendingIntent = CreatePendingIntent(ActionBroadcastReceiver.ACTION_MENU_ITEM);
                intentBuilder.AddMenuItem(menuItemTitle, menuItemPendingIntent);
            }

            if (mAddDefaultShareCheckbox.Checked)
            {
                intentBuilder.AddDefaultShareMenuItem();
            }

            if (mToolbarItemCheckbox.Checked)
            {
                //Generally you do not want to decode bitmaps in the UI thread. Decoding it in the
                //UI thread to keep the example short.
                string        actionLabel   = GetString(Resource.String.label_action);
                Bitmap        icon          = BitmapFactory.DecodeResource(Resources, Android.Resource.Drawable.IcMenuShare);
                PendingIntent pendingIntent = CreatePendingIntent(ActionBroadcastReceiver.ACTION_TOOLBAR);
                intentBuilder.AddToolbarItem(TOOLBAR_ITEM_ID, icon, actionLabel, pendingIntent);
            }

            intentBuilder.SetShowTitle(mShowTitleCheckBox.Checked);

            if (mAutoHideAppBarCheckbox.Checked)
            {
                intentBuilder.EnableUrlBarHiding();
            }

            if (mCustomBackButtonCheckBox.Checked)
            {
                intentBuilder.SetCloseButtonIcon(BitmapFactory.DecodeResource(Resources, Resource.Drawable.ic_arrow_back));
            }
            intentBuilder.SetStartAnimations(this, Resource.Animation.slide_in_right, Resource.Animation.slide_out_left);
            intentBuilder.SetExitAnimations(this, Android.Resource.Animation.SlideInLeft, Android.Resource.Animation.SlideOutRight);

            CustomTabActivityHelper.OpenCustomTab(
                this, intentBuilder.Build(), Uri.Parse(url), new WebviewFallback());
        }
        private void LaunchCustomTabs(string url)
        {
            var packageName = CustomTabsHelper.GetPackageNameToUse(this);

            if (string.IsNullOrEmpty(packageName))
            {
                // in case custom tabs are not supported, use the browser

                StartActivity(new Intent(Intent.ActionView, Android.Net.Uri.Parse(url)));
            }
            else
            {
                // use custom tabs

                var mgr              = new CustomTabsActivityManager(this);
                var builder          = new CustomTabsIntent.Builder(mgr.Session);
                var customTabsIntent = builder
                                       .SetToolbarColor(new Color(0x34, 0x98, 0xDB))
                                       .SetShowTitle(true)
                                       .EnableUrlBarHiding()
                                       .Build();
                customTabsIntent.Intent.AddFlags(ActivityFlags.NoHistory);
                customTabsIntent.Intent.SetPackage(packageName);

                customTabsIntent.LaunchUrl(this, Android.Net.Uri.Parse(url));
            }
        }
Beispiel #3
0
        static Task <bool> PlatformOpenAsync(Uri uri, BrowserLaunchOptions options)
        {
            var nativeUri = AndroidUri.Parse(uri.AbsoluteUri);

            switch (options.LaunchMode)
            {
            case BrowserLaunchMode.SystemPreferred:
                var tabsBuilder = new CustomTabsIntent.Builder();
                tabsBuilder.SetShowTitle(true);
                if (options.PreferredToolbarColor.HasValue)
                {
                    tabsBuilder.SetToolbarColor(options.PreferredToolbarColor.Value.ToInt());
                }
                if (options.TitleMode != BrowserTitleMode.Default)
                {
                    tabsBuilder.SetShowTitle(options.TitleMode == BrowserTitleMode.Show);
                }

                var tabsIntent = tabsBuilder.Build();
                var flags      = ActivityFlags.ClearTop | ActivityFlags.NewTask;
#if __ANDROID_24__
                if (Platform.HasApiLevelN)
                {
                    flags |= ActivityFlags.LaunchAdjacent;
                }
#endif
                tabsIntent.Intent.SetFlags(flags);

#if __ANDROID_25__
                tabsIntent.LaunchUrl(Platform.AppContext, nativeUri);
#else
                tabsIntent.LaunchUrl(Platform.GetCurrentActivity(true), nativeUri);
#endif
                break;

            case BrowserLaunchMode.External:
                var intent = new Intent(Intent.ActionView, nativeUri);
                flags = ActivityFlags.ClearTop | ActivityFlags.NewTask;
#if __ANDROID_24__
                if (Platform.HasApiLevelN)
                {
                    flags |= ActivityFlags.LaunchAdjacent;
                }
#endif
                intent.SetFlags(flags);

                if (!Platform.IsIntentSupported(intent))
                {
                    throw new FeatureNotSupportedException();
                }

                Platform.AppContext.StartActivity(intent);
                break;
            }

            return(Task.FromResult(true));
        }
Beispiel #4
0
        static void LaunchChromeTabs(BrowserLaunchOptions options, AndroidUri?nativeUri)
        {
            var tabsBuilder = new CustomTabsIntent.Builder();

            tabsBuilder.SetShowTitle(true);
#pragma warning disable CS0618 // Type or member is obsolete
            if (options.PreferredToolbarColor != null)
            {
                tabsBuilder.SetToolbarColor(options.PreferredToolbarColor.ToInt());
            }
#pragma warning restore CS0618 // Type or member is obsolete
            if (options.TitleMode != BrowserTitleMode.Default)
            {
                tabsBuilder.SetShowTitle(options.TitleMode == BrowserTitleMode.Show);
            }

            var           tabsIntent = tabsBuilder.Build();
            ActivityFlags?tabsFlags  = null;

            Context?context = ActivityStateManager.Default.GetCurrentActivity(false);

            if (context == null)
            {
                context = Application.Context;

                // If using ApplicationContext we need to set ClearTop/NewTask (See #225)
                tabsFlags = ActivityFlags.ClearTop | ActivityFlags.NewTask;
            }

#if __ANDROID_24__
            if (OperatingSystem.IsAndroidVersionAtLeast(24))
            {
                if (options.HasFlag(BrowserLaunchFlags.LaunchAdjacent))
                {
                    if (tabsFlags.HasValue)
                    {
                        tabsFlags |= ActivityFlags.LaunchAdjacent | ActivityFlags.NewTask;
                    }
                    else
                    {
                        tabsFlags = ActivityFlags.LaunchAdjacent | ActivityFlags.NewTask;
                    }
                }
            }
#endif

            // Check if there's flags specified to use
            if (tabsFlags.HasValue)
            {
                tabsIntent.Intent.SetFlags(tabsFlags.Value);
            }

            if (nativeUri != null)
            {
                tabsIntent.LaunchUrl(context, nativeUri);
            }
        }
Beispiel #5
0
        public Task OpenBrowser(string url)
        {
            var tabsBuilder = new CustomTabsIntent.Builder();

            tabsBuilder.SetShowTitle(true);
            tabsBuilder.SetToolbarColor(ColorConstants.BrowserNavigationBarBackgroundColor.ToAndroid());
            tabsBuilder.SetSecondaryToolbarColor(ColorConstants.BrowserNavigationBarTextColor.ToAndroid());

            var intent = tabsBuilder.Build();

            intent.LaunchUrl(CurrentContext, Android.Net.Uri.Parse(url));

            return(Task.CompletedTask);
        }
Beispiel #6
0
        public void OnClick(View view)
        {
            string url = mEditText.Text;
            bool   success;

            switch (view.Id)
            {
            case Resource.Id.connect_button:
                BindCustomTabsService();
                break;

            case Resource.Id.warmup_button:
                success = false;
                if (mClient != null)
                {
                    success = mClient.Warmup(0);
                }
                mWarmupButton.Enabled &= success;
                break;

            case Resource.Id.may_launch_button:
                CustomTabsSession session = GetSession();
                success = false;
                if (mClient != null)
                {
                    success = session.MayLaunchUrl(Uri.Parse(url), null, null);
                }
                mMayLaunchButton.Enabled &= success;
                break;

            case Resource.Id.launch_button:
                var builder = new CustomTabsIntent.Builder(GetSession());
                builder.SetToolbarColor(Color.ParseColor(TOOLBAR_COLOR)).SetShowTitle(true);
                PrepareMenuItems(builder);
                PrepareActionButton(builder);
                PrepareBottombar(builder);
                builder.SetStartAnimations(this, Resource.Animation.slide_in_right, Resource.Animation.slide_out_left);
                builder.SetExitAnimations(this, Resource.Animation.slide_in_left, Resource.Animation.slide_out_right);
                builder.SetCloseButtonIcon(BitmapFactory.DecodeResource(Resources, Resource.Drawable.ic_arrow_back));
                CustomTabsIntent customTabsIntent = builder.Build();
                CustomTabsHelper.AddKeepAliveExtra(this, customTabsIntent.Intent);
                customTabsIntent.LaunchUrl(this, Uri.Parse(url));
                break;
            }
        }
        /// <summary>
        /// Open a browser to a specific url
        /// </summary>
        /// <param name="url">Url to open</param>
        /// <param name="options">Platform specific options</param>
        /// <returns>True if the operation was successful, false otherwise</returns>
        public Task <bool> OpenBrowser(string url, BrowserOptions options = null)
        {
            try
            {
                if (options == null)
                {
                    options = new BrowserOptions();
                }

                if (CrossCurrentActivity.Current.Activity == null)
                {
                    var intent = new Intent(Intent.ActionView);
                    intent.SetData(Android.Net.Uri.Parse(url));

                    intent.SetFlags(ActivityFlags.ClearTop);
                    intent.SetFlags(ActivityFlags.NewTask);
                    Application.Context.StartActivity(intent);
                }
                else
                {
                    var tabsBuilder = new CustomTabsIntent.Builder();
                    tabsBuilder.SetShowTitle(options?.ChromeShowTitle ?? false);

                    var toolbarColor = options?.ChromeToolbarColor;
                    if (toolbarColor != null)
                    {
                        tabsBuilder.SetToolbarColor(toolbarColor.ToNativeColor());
                    }

                    var intent = tabsBuilder.Build();
                    intent.LaunchUrl(CrossCurrentActivity.Current.Activity, Android.Net.Uri.Parse(url));
                }

                return(Task.FromResult(true));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Unable to open browser: " + ex.Message);
                return(Task.FromResult(false));
            }
        }
Beispiel #8
0
        static Task <bool> PlatformOpenAsync(Uri uri, BrowserLaunchOptions options)
        {
            var nativeUri = AndroidUri.Parse(uri.AbsoluteUri);

            switch (options.LaunchMode)
            {
            case BrowserLaunchMode.SystemPreferred:
                var tabsBuilder = new CustomTabsIntent.Builder();
                tabsBuilder.SetShowTitle(true);
                if (options.PreferredToolbarColor.HasValue)
#pragma warning disable CS0618 // Type or member is obsolete
                {
                    tabsBuilder.SetToolbarColor(options.PreferredToolbarColor.Value.ToInt());
                }
#pragma warning restore CS0618 // Type or member is obsolete
                if (options.TitleMode != BrowserTitleMode.Default)
                {
                    tabsBuilder.SetShowTitle(options.TitleMode == BrowserTitleMode.Show);
                }

                var           tabsIntent = tabsBuilder.Build();
                ActivityFlags?tabsFlags  = null;

                Context context = Platform.GetCurrentActivity(false);

                if (context == null)
                {
                    context = Platform.AppContext;

                    // If using ApplicationContext we need to set ClearTop/NewTask (See #225)
                    tabsFlags = ActivityFlags.ClearTop | ActivityFlags.NewTask;
                }

#if __ANDROID_24__
                if (Platform.HasApiLevelN && options.HasFlag(BrowserLaunchFlags.LaunchAdjacent))
                {
                    if (tabsFlags.HasValue)
                    {
                        tabsFlags |= ActivityFlags.LaunchAdjacent | ActivityFlags.NewTask;
                    }
                    else
                    {
                        tabsFlags = ActivityFlags.LaunchAdjacent | ActivityFlags.NewTask;
                    }
                }
#endif

                // Check if there's flags specified to use
                if (tabsFlags.HasValue)
                {
                    tabsIntent.Intent.SetFlags(tabsFlags.Value);
                }

                tabsIntent.LaunchUrl(context, nativeUri);

                break;

            case BrowserLaunchMode.External:
                var intent = new Intent(Intent.ActionView, nativeUri);
                var flags  = ActivityFlags.ClearTop | ActivityFlags.NewTask;
#if __ANDROID_24__
                if (Platform.HasApiLevelN && options.HasFlag(BrowserLaunchFlags.LaunchAdjacent))
                {
                    flags |= ActivityFlags.LaunchAdjacent;
                }
#endif
                intent.SetFlags(flags);

                if (!Platform.IsIntentSupported(intent))
                {
                    throw new FeatureNotSupportedException();
                }

                Platform.AppContext.StartActivity(intent);
                break;
            }

            return(Task.FromResult(true));
        }
Beispiel #9
0
        public void OnClick(View v)
        {
            string url    = mEditText.Text.ToString();
            int    viewId = v.Id;

            if (viewId == Resource.Id.connect_button)
            {
                BindCustomTabsService();
            }
            else if (viewId == Resource.Id.warmup_button)
            {
                bool success = false;
                if (custom_tabs_client != null)
                {
                    success = custom_tabs_client.Warmup(0);
                }
                if (!success)
                {
                    mWarmupButton.Enabled = false;
                }
            }
            else if (viewId == Resource.Id.may_launch_button)
            {
                CustomTabsSession session = Session;
                bool success = false;
                if (custom_tabs_client != null)
                {
                    success = session.MayLaunchUrl(Android.Net.Uri.Parse(url), null, null);
                }
                if (!success)
                {
                    mMayLaunchButton.Enabled = false;
                }
            }
            else if (viewId == Resource.Id.launch_button)
            {
                CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder(Session);
                builder.SetToolbarColor(Color.ParseColor(TOOLBAR_COLOR)).SetShowTitle(true);
                PrepareMenuItems(builder);
                PrepareActionButton(builder);
                PrepareBottomBar(builder);

                builder.SetStartAnimations
                (
                    this,
                    Resource.Animation.slide_in_right,
                    Resource.Animation.slide_out_left
                );
                builder.SetExitAnimations
                (
                    this,
                    Android.Resource.Animation.SlideInLeft,
                    Android.Resource.Animation.SlideOutRight
                );
                builder.SetCloseButtonIcon(BitmapFactory.DecodeResource(Resources, Resource.Drawable.ic_arrow_back));


                CustomTabsIntent customTabsIntent = builder.Build();
                // derived class used - thus FQNS
                HolisticWare.Android.Support.CustomTabs.Chromium.SharedUtilities.
                CustomTabsHelper.AddKeepAliveExtra(this, customTabsIntent.Intent);

                try
                {
                    customTabsIntent.LaunchUrl(this, Android.Net.Uri.Parse(url));
                }
                catch (System.Exception exc)
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("CustomTabsIntent.LaunchUrl Exception");
                }
                return;
            }
        }