diff --git a/ChangeLog.txt b/ChangeLog.txt
index 209abbd01..918fb38d5 100644
--- a/ChangeLog.txt
+++ b/ChangeLog.txt
@@ -1,5 +1,11 @@
 Google Mobile Ads Unity Plugin Change Log
 
+**************
+Version Next
+**************
+
+- Added Picture-in-Picture ad support.
+
 **************
 Version 11.4.0
 **************
diff --git a/source/plugin/Assets/GoogleMobileAds/Api/Core/PictureInPictureAdPosition.cs b/source/plugin/Assets/GoogleMobileAds/Api/Core/PictureInPictureAdPosition.cs
new file mode 100644
index 000000000..9f9b5fb16
--- /dev/null
+++ b/source/plugin/Assets/GoogleMobileAds/Api/Core/PictureInPictureAdPosition.cs
@@ -0,0 +1,25 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace GoogleMobileAds.Api
+{
+    public enum PictureInPictureAdPosition
+    {
+        Default = 0,
+        BottomRight = 1,
+        BottomLeft = 2,
+        TopLeft = 3,
+        TopRight = 4
+    }
+}
diff --git a/source/plugin/Assets/GoogleMobileAds/Api/PictureInPictureAd.cs b/source/plugin/Assets/GoogleMobileAds/Api/PictureInPictureAd.cs
new file mode 100644
index 000000000..d12ea96fb
--- /dev/null
+++ b/source/plugin/Assets/GoogleMobileAds/Api/PictureInPictureAd.cs
@@ -0,0 +1,241 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using UnityEngine;
+using GoogleMobileAds.Common;
+
+namespace GoogleMobileAds.Api
+{
+    /// <summary>
+    /// A Picture-in-Picture (PiP) ad that displays in a floating window across screens.
+    /// </summary>
+    public class PictureInPictureAd
+    {
+        /// <summary>
+        /// Raised when the ad is estimated to have earned money.
+        /// </summary>
+        public event Action<AdValue> OnAdPaid;
+
+        /// <summary>
+        /// Raised when an ad is clicked.
+        /// </summary>
+        public event Action OnAdClicked;
+
+        /// <summary>
+        /// Raised when an impression is recorded for an ad.
+        /// </summary>
+        public event Action OnAdImpressionRecorded;
+
+        /// <summary>
+        /// Raised when the PiP ad is displayed on the screen.
+        /// </summary>
+        public event Action OnAdShown;
+
+        /// <summary>
+        /// Raised when the PiP ad is hidden from the screen.
+        /// </summary>
+        public event Action OnAdHidden;
+
+        /// <summary>
+        /// Raised when an ad opened full-screen content.
+        /// </summary>
+        public event Action OnAdFullScreenContentOpened;
+
+        /// <summary>
+        /// Raised when the ad closed full-screen content.
+        /// </summary>
+        public event Action OnAdFullScreenContentClosed;
+
+        protected internal IPictureInPictureAdClient _client;
+
+        protected internal PictureInPictureAd() {}
+
+        internal PictureInPictureAd(IPictureInPictureAdClient client)
+        {
+            _client = client;
+            RegisterAdEvents();
+        }
+
+        /// <summary>
+        /// Loads a Picture-in-Picture ad.
+        /// </summary>
+        public static void Load(string adUnitId,
+                                AdRequest request,
+                                Action<PictureInPictureAd, LoadAdError> adLoadCallback)
+        {
+            if (adLoadCallback == null)
+            {
+                Debug.LogError("adLoadCallback is null. No ad was loaded.");
+                return;
+            }
+
+            var client = MobileAds.GetClientFactory().BuildPictureInPictureAdClient();
+            client.CreatePictureInPictureAd();
+            client.OnAdLoaded += (sender, args) =>
+            {
+                var pipAd = new PictureInPictureAd(client);
+                MobileAds.RaiseAction(() =>
+                {
+                    adLoadCallback(pipAd, null);
+                });
+            };
+            client.OnAdFailedToLoad += (sender, error) =>
+            {
+                var loadAdError = (error != null && error.LoadAdErrorClient != null)
+                    ? new LoadAdError(error.LoadAdErrorClient)
+                    : null;
+                MobileAds.RaiseAction(() =>
+                {
+                    adLoadCallback(null, loadAdError);
+                });
+            };
+            client.LoadAd(adUnitId, request);
+        }
+
+        /// <summary>
+        /// Shows the Picture-in-Picture ad on the screen at the specified corner position.
+        /// </summary>
+        public void Show(PictureInPictureAdPosition position = PictureInPictureAdPosition.Default)
+        {
+            if (_client != null)
+            {
+                _client.Show(position);
+            }
+        }
+
+        /// <summary>
+        /// Hides the Picture-in-Picture ad from the screen.
+        /// </summary>
+        public void Hide()
+        {
+            if (_client != null)
+            {
+                _client.Hide();
+            }
+        }
+
+        /// <summary>
+        /// Destroys the Picture-in-Picture ad and cleans up native resources.
+        /// </summary>
+        public void Destroy()
+        {
+            if (_client != null)
+            {
+                _client.Destroy();
+            }
+        }
+
+        /// <summary>
+        /// Returns the ResponseInfo for the loaded ad, or null if unavailable.
+        /// </summary>
+        public ResponseInfo GetResponseInfo()
+        {
+            return _client != null ? new ResponseInfo(_client.GetResponseInfoClient()) : null;
+        }
+
+        /// <summary>
+        /// Returns the current or last known position of the Picture-in-Picture ad.
+        /// </summary>
+        public PictureInPictureAdPosition GetAdPosition()
+        {
+            return _client != null ? _client.GetAdPosition() : PictureInPictureAdPosition.Default;
+        }
+
+        private void RegisterAdEvents()
+        {
+            if (_client == null)
+            {
+                return;
+            }
+
+            _client.OnAdShown += (sender, args) =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdShown != null)
+                    {
+                        OnAdShown();
+                    }
+                });
+            };
+
+            _client.OnAdHidden += (sender, args) =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdHidden != null)
+                    {
+                        OnAdHidden();
+                    }
+                });
+            };
+
+            _client.OnAdClicked += () =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdClicked != null)
+                    {
+                        OnAdClicked();
+                    }
+                });
+            };
+
+            _client.OnAdDidRecordImpression += (sender, args) =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdImpressionRecorded != null)
+                    {
+                        OnAdImpressionRecorded();
+                    }
+                });
+            };
+
+            _client.OnAdDidPresentFullScreenContent += (sender, args) =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdFullScreenContentOpened != null)
+                    {
+                        OnAdFullScreenContentOpened();
+                    }
+                });
+            };
+
+            _client.OnAdDidDismissFullScreenContent += (sender, args) =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdFullScreenContentClosed != null)
+                    {
+                        OnAdFullScreenContentClosed();
+                    }
+                });
+            };
+
+            _client.OnPaidEvent += (adValue) =>
+            {
+                MobileAds.RaiseAction(() =>
+                {
+                    if (OnAdPaid != null)
+                    {
+                        OnAdPaid(adValue);
+                    }
+                });
+            };
+        }
+    }
+}
diff --git a/source/plugin/Assets/GoogleMobileAds/Common/IClientFactory.cs b/source/plugin/Assets/GoogleMobileAds/Common/IClientFactory.cs
index 37c2e0f7d..df2a08b86 100644
--- a/source/plugin/Assets/GoogleMobileAds/Common/IClientFactory.cs
+++ b/source/plugin/Assets/GoogleMobileAds/Common/IClientFactory.cs
@@ -38,6 +38,8 @@ public interface IClientFactory
 
         INativeOverlayAdClient BuildNativeOverlayAdClient();
 
+        IPictureInPictureAdClient BuildPictureInPictureAdClient();
+
         IApplicationPreferencesClient ApplicationPreferencesInstance();
 
         IMobileAdsClient MobileAdsInstance();
diff --git a/source/plugin/Assets/GoogleMobileAds/Common/IPictureInPictureAdClient.cs b/source/plugin/Assets/GoogleMobileAds/Common/IPictureInPictureAdClient.cs
new file mode 100644
index 000000000..b6a8fdb22
--- /dev/null
+++ b/source/plugin/Assets/GoogleMobileAds/Common/IPictureInPictureAdClient.cs
@@ -0,0 +1,62 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using GoogleMobileAds.Api;
+
+namespace GoogleMobileAds.Common
+{
+    public interface IPictureInPictureAdClient
+    {
+        // Ad event fired when the picture in picture ad has loaded.
+        event EventHandler<EventArgs> OnAdLoaded;
+        // Ad event fired when the picture in picture ad has failed to load.
+        event EventHandler<LoadAdErrorClientEventArgs> OnAdFailedToLoad;
+        // Ad event fired when the picture in picture ad is displayed on screen.
+        event EventHandler<EventArgs> OnAdShown;
+        // Ad event fired when the picture in picture ad is hidden from screen.
+        event EventHandler<EventArgs> OnAdHidden;
+        // Ad event fired when an ad impression has been recorded.
+        event EventHandler<EventArgs> OnAdDidRecordImpression;
+        // Ad event fired when an ad has been clicked.
+        event Action OnAdClicked;
+        // Ad event fired when the ad opens an overlay covering the screen.
+        event EventHandler<EventArgs> OnAdDidPresentFullScreenContent;
+        // Ad event fired when the ad overlay is dismissed.
+        event EventHandler<EventArgs> OnAdDidDismissFullScreenContent;
+        // Ad event fired when the picture in picture ad is estimated to have earned money.
+        event Action<AdValue> OnPaidEvent;
+
+        // Creates a picture in picture ad wrapper.
+        void CreatePictureInPictureAd();
+
+        // Loads a picture in picture ad.
+        void LoadAd(string adUnitId, AdRequest request);
+
+        // Shows the picture in picture ad on screen.
+        void Show(PictureInPictureAdPosition position);
+
+        // Hides the picture in picture ad.
+        void Hide();
+
+        // Destroys the picture in picture ad.
+        void Destroy();
+
+        // Returns the current or last known position of the picture in picture ad.
+        PictureInPictureAdPosition GetAdPosition();
+
+        // Returns the response info for the loaded ad.
+        IResponseInfoClient GetResponseInfoClient();
+    }
+}
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/Android/GoogleMobileAdsClientFactory.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/Android/GoogleMobileAdsClientFactory.cs
index b51a39967..f0d243169 100644
--- a/source/plugin/Assets/GoogleMobileAds/Platforms/Android/GoogleMobileAdsClientFactory.cs
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/Android/GoogleMobileAdsClientFactory.cs
@@ -146,6 +146,16 @@ public INativeOverlayAdClient BuildNativeOverlayAdClient()
             " on non-Android runtime");
         }
 
+        public IPictureInPictureAdClient BuildPictureInPictureAdClient()
+        {
+            if (Application.platform == RuntimePlatform.Android)
+            {
+                return new GoogleMobileAds.Android.PictureInPictureAdClient();
+            }
+            throw new InvalidOperationException(@"Called " + MethodBase.GetCurrentMethod().Name +
+            " on non-Android runtime");
+        }
+
         public IApplicationPreferencesClient ApplicationPreferencesInstance() {
           if (Application.platform == RuntimePlatform.Android) {
             return new GoogleMobileAds.Android.ApplicationPreferencesClient();
@@ -180,7 +190,7 @@ private bool IsNextGenEnabled()
                     new AndroidJavaClass(GoogleMobileAds.Android.NextGenUtils.MobileAdsClassName);
                 _nextGenEnabled = true;
             }
-            catch (AndroidJavaException)
+            catch (Exception)
             {
                 _nextGenEnabled = false;
             }
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/Android/NextGenUtils.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/Android/NextGenUtils.cs
index 42305e04f..3f062a486 100644
--- a/source/plugin/Assets/GoogleMobileAds/Platforms/Android/NextGenUtils.cs
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/Android/NextGenUtils.cs
@@ -120,6 +120,11 @@ internal class NextGenUtils {
     public const string UnityBannerAdCallbackClassName =
         "com.google.unity.ads.nextgen.UnityBannerAdCallback";
 
+    public const string UnityPictureInPictureAdClassName =
+        "com.google.unity.ads.nextgen.UnityPictureInPictureAd";
+    public const string UnityPictureInPictureAdCallbackClassName =
+        "com.google.unity.ads.nextgen.UnityPictureInPictureAdCallback";
+
     public const string UnityInterstitialAdClassName =
         "com.google.unity.ads.nextgen.UnityInterstitialAd";
     public const string UnityInterstitialAdCallbackClassName =
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/Android/PictureInPictureAdClient.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/Android/PictureInPictureAdClient.cs
new file mode 100644
index 000000000..03398fcdf
--- /dev/null
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/Android/PictureInPictureAdClient.cs
@@ -0,0 +1,166 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using GoogleMobileAds.Api;
+using GoogleMobileAds.Common;
+using UnityEngine;
+
+namespace GoogleMobileAds.Android
+{
+    public class PictureInPictureAdClient : AndroidJavaProxy, IPictureInPictureAdClient
+    {
+        internal AndroidJavaObject androidPictureInPictureAd;
+
+        public PictureInPictureAdClient() : base(NextGenUtils.UnityPictureInPictureAdCallbackClassName)
+        {
+            AndroidJavaClass playerClass = new AndroidJavaClass(Utils.UnityActivityClassName);
+            AndroidJavaObject activity = playerClass.GetStatic<AndroidJavaObject>("currentActivity");
+            this.androidPictureInPictureAd = new AndroidJavaObject(
+                NextGenUtils.UnityPictureInPictureAdClassName, activity, this);
+        }
+
+        public event EventHandler<EventArgs> OnAdLoaded;
+        public event EventHandler<LoadAdErrorClientEventArgs> OnAdFailedToLoad;
+        public event EventHandler<EventArgs> OnAdShown;
+        public event EventHandler<EventArgs> OnAdHidden;
+        public event EventHandler<EventArgs> OnAdDidRecordImpression;
+        public event Action OnAdClicked;
+        public event EventHandler<EventArgs> OnAdDidPresentFullScreenContent;
+        public event EventHandler<EventArgs> OnAdDidDismissFullScreenContent;
+        public event Action<AdValue> OnPaidEvent;
+
+        public void CreatePictureInPictureAd()
+        {
+            // No-op for Next-Gen.
+        }
+
+        public void LoadAd(string adUnitId, AdRequest request)
+        {
+            this.androidPictureInPictureAd.Call("load", adUnitId, NextGenUtils.GetAdRequestJavaObject(request, adUnitId));
+        }
+
+        public void Show(PictureInPictureAdPosition position)
+        {
+            this.androidPictureInPictureAd.Call("show", (int)position);
+        }
+
+        public void Hide()
+        {
+            this.androidPictureInPictureAd.Call("hide");
+        }
+
+        public void Destroy()
+        {
+            this.androidPictureInPictureAd.Call("destroy");
+        }
+
+        public PictureInPictureAdPosition GetAdPosition()
+        {
+            int ordinal = this.androidPictureInPictureAd.Call<int>("getAdPosition");
+            return (PictureInPictureAdPosition)ordinal;
+        }
+
+        public IResponseInfoClient GetResponseInfoClient()
+        {
+            return new ResponseInfoClient(ResponseInfoClientType.AdLoaded, this.androidPictureInPictureAd);
+        }
+
+        #region Callback methods called from Java via AndroidJavaProxy
+
+        public void onAdLoaded()
+        {
+            if (this.OnAdLoaded != null)
+            {
+                this.OnAdLoaded(this, EventArgs.Empty);
+            }
+        }
+
+        public void onAdFailedToLoad(AndroidJavaObject error)
+        {
+            if (this.OnAdFailedToLoad != null)
+            {
+                LoadAdErrorClientEventArgs args = new LoadAdErrorClientEventArgs
+                {
+                    LoadAdErrorClient = new NextGenLoadAdErrorClient(error)
+                };
+                this.OnAdFailedToLoad(this, args);
+            }
+        }
+
+        public void onAdShown()
+        {
+            if (this.OnAdShown != null)
+            {
+                this.OnAdShown(this, EventArgs.Empty);
+            }
+        }
+
+        public void onAdHidden()
+        {
+            if (this.OnAdHidden != null)
+            {
+                this.OnAdHidden(this, EventArgs.Empty);
+            }
+        }
+
+        public void onAdClicked()
+        {
+            if (this.OnAdClicked != null)
+            {
+                this.OnAdClicked();
+            }
+        }
+
+        public void onAdImpression()
+        {
+            if (this.OnAdDidRecordImpression != null)
+            {
+                this.OnAdDidRecordImpression(this, EventArgs.Empty);
+            }
+        }
+
+        public void onAdShowedFullScreenContent()
+        {
+            if (this.OnAdDidPresentFullScreenContent != null)
+            {
+                this.OnAdDidPresentFullScreenContent(this, EventArgs.Empty);
+            }
+        }
+
+        public void onAdDismissedFullScreenContent()
+        {
+            if (this.OnAdDidDismissFullScreenContent != null)
+            {
+                this.OnAdDidDismissFullScreenContent(this, EventArgs.Empty);
+            }
+        }
+
+        public void onPaidEvent(int precision, long valueMicros, string currencyCode)
+        {
+            if (this.OnPaidEvent != null)
+            {
+                AdValue adValue = new AdValue
+                {
+                    Precision = (AdValue.PrecisionType)precision,
+                    Value = valueMicros,
+                    CurrencyCode = currencyCode
+                };
+                this.OnPaidEvent(adValue);
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/GoogleMobileAdsClientFactory.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/GoogleMobileAdsClientFactory.cs
index aab163f16..c0379d60c 100644
--- a/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/GoogleMobileAdsClientFactory.cs
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/GoogleMobileAdsClientFactory.cs
@@ -78,6 +78,11 @@ public IMobileAdsClient MobileAdsInstance()
             return new GoogleMobileAds.Unity.MobileAdsClient();
         }
 
+        public IPictureInPictureAdClient BuildPictureInPictureAdClient()
+        {
+            return new GoogleMobileAds.Unity.PictureInPictureAdClient();
+        }
+
 #if GMA_PREVIEW_FEATURES
 
         public IAppOpenAdPreloaderClient BuildAppOpenAdPreloaderClient() {
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/PictureInPictureAdClient.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/PictureInPictureAdClient.cs
new file mode 100644
index 000000000..5194aab01
--- /dev/null
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/Unity/PictureInPictureAdClient.cs
@@ -0,0 +1,779 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+using GoogleMobileAds.Api;
+using GoogleMobileAds.Common;
+
+namespace GoogleMobileAds.Unity
+{
+    public class PictureInPictureAdClient : IPictureInPictureAdClient
+    {
+        public event EventHandler<EventArgs> OnAdLoaded;
+        public event EventHandler<LoadAdErrorClientEventArgs> OnAdFailedToLoad;
+        public event EventHandler<EventArgs> OnAdShown;
+        public event EventHandler<EventArgs> OnAdHidden;
+        public event EventHandler<EventArgs> OnAdDidRecordImpression;
+        public event Action OnAdClicked;
+        public event EventHandler<EventArgs> OnAdDidPresentFullScreenContent;
+        public event EventHandler<EventArgs> OnAdDidDismissFullScreenContent;
+        public event Action<AdValue> OnPaidEvent;
+
+        private GameObject _gameObject;
+        private RectTransform _cardRect;
+        private PipSimulatorComponent _simulatorComponent;
+        private string _adUnitId;
+        private PictureInPictureAdPosition _currentPosition = PictureInPictureAdPosition.Default;
+        private bool _isLoaded = false;
+        private bool _didImpress = false;
+
+        public void CreatePictureInPictureAd()
+        {
+            // No-op for Unity Editor simulator.
+        }
+
+        public void LoadAd(string adUnitId, AdRequest request)
+        {
+            _adUnitId = adUnitId;
+            if (string.IsNullOrEmpty(adUnitId) || request == null)
+            {
+                if (OnAdFailedToLoad != null)
+                {
+                    OnAdFailedToLoad.Invoke(this, new LoadAdErrorClientEventArgs
+                    {
+                        LoadAdErrorClient = new LoadAdErrorClient()
+                    });
+                }
+                return;
+            }
+
+            GameObject prefab = Resources.Load("PlaceholderAds/Banners/MEDIUM_RECTANGLE") as GameObject;
+            if (prefab == null)
+            {
+                prefab = Resources.Load("PlaceholderAds/Banners/BANNER") as GameObject;
+            }
+            if (prefab == null)
+            {
+                Debug.LogError("No PiP placeholder prefab found in Resources.");
+                if (OnAdFailedToLoad != null)
+                {
+                    OnAdFailedToLoad.Invoke(this, new LoadAdErrorClientEventArgs
+                    {
+                        LoadAdErrorClient = new LoadAdErrorClient()
+                    });
+                }
+                return;
+            }
+
+            _gameObject = GameObject.Instantiate(prefab);
+            Canvas canvas = _gameObject.GetComponent<Canvas>();
+            if (canvas != null)
+            {
+                // Set to maximum sorting order to render on top of scene UI.
+                canvas.sortingOrder = 32767;
+            }
+
+            // Remove existing Button component on prefab so dragging does not trigger button click
+            Button existingButton = _gameObject.GetComponentInChildren<Button>();
+            Image bannerImage = _gameObject.GetComponentInChildren<Image>();
+            Text bannerText = _gameObject.GetComponentInChildren<Text>();
+
+            if (bannerText != null)
+            {
+                bannerText.text = "Picture-in-Picture Test Ad";
+            }
+
+            if (existingButton != null)
+            {
+                GameObject.Destroy(existingButton);
+            }
+
+            // Create outer card container (#737373 gray frame with 12px rounded corners matching Android outerClippingRadiusDp)
+            // 300x250 ad + 4px padding (top/left/right) + 32px padding (bottom) -> Size: 308 x 286
+            GameObject cardObject = new GameObject("PipCardFrame");
+            cardObject.transform.SetParent(_gameObject.transform, false);
+            _cardRect = cardObject.AddComponent<RectTransform>();
+            _cardRect.sizeDelta = new Vector2(308f, 286f);
+
+            Image cardBg = cardObject.AddComponent<Image>();
+            cardBg.sprite = GetOrCreateRoundedCardSprite(12);
+            cardBg.type = Image.Type.Sliced;
+            cardBg.color = Color.white;
+
+            // Parent banner image inside an inner rounded mask (8px corner radius matching Android innerClippingRadiusDp)
+            // This ensures the ad image corners do not poke out of the outer card's rounded corners.
+            if (bannerImage != null)
+            {
+                GameObject maskObject = new GameObject("PipAdMaskContainer");
+                maskObject.transform.SetParent(_cardRect, false);
+                RectTransform maskRect = maskObject.AddComponent<RectTransform>();
+                maskRect.anchorMin = new Vector2(0.5f, 1f);
+                maskRect.anchorMax = new Vector2(0.5f, 1f);
+                maskRect.pivot = new Vector2(0.5f, 1f);
+                maskRect.sizeDelta = new Vector2(300f, 250f);
+                maskRect.anchoredPosition = new Vector2(0f, -4f); // 4px padding from top
+
+                Image maskImage = maskObject.AddComponent<Image>();
+                maskImage.sprite = GetOrCreateRoundedMaskSprite(8);
+                maskImage.type = Image.Type.Sliced;
+
+                Mask mask = maskObject.AddComponent<Mask>();
+                mask.showMaskGraphic = false;
+
+                RectTransform bannerRect = bannerImage.GetComponent<RectTransform>();
+                bannerRect.SetParent(maskRect, false);
+                bannerRect.anchorMin = Vector2.zero;
+                bannerRect.anchorMax = Vector2.one;
+                bannerRect.pivot = new Vector2(0.5f, 0.5f);
+                bannerRect.sizeDelta = Vector2.zero;
+                bannerRect.anchoredPosition = Vector2.zero;
+            }
+
+            // Create bottom-left countdown & close button widget in the 32px bottom padding strip
+            GameObject badgeObject = new GameObject("PipCloseCountdownBadge");
+            badgeObject.transform.SetParent(_cardRect, false);
+            RectTransform badgeRect = badgeObject.AddComponent<RectTransform>();
+            badgeRect.anchorMin = new Vector2(0f, 0f);
+            badgeRect.anchorMax = new Vector2(0f, 0f);
+            badgeRect.pivot = new Vector2(0f, 0f);
+            badgeRect.sizeDelta = new Vector2(24f, 24f);
+            badgeRect.anchoredPosition = new Vector2(8f, 4f); // Bottom-left alignment in bottom strip
+
+            Image badgeBg = badgeObject.AddComponent<Image>();
+            badgeBg.sprite = GetOrCreateBadgeSprite(BadgeType.Countdown3);
+            badgeBg.color = Color.white;
+
+            Button closeButton = badgeObject.AddComponent<Button>();
+            closeButton.interactable = false;
+
+            // Attach simulator component to handle dragging, click separation, smooth snapping, and countdown
+            _simulatorComponent = cardObject.AddComponent<PipSimulatorComponent>();
+            _simulatorComponent.Initialize(this, badgeBg, closeButton);
+            _simulatorComponent.OnCornerSnapped = (snappedCorner) =>
+            {
+                _currentPosition = snappedCorner;
+            };
+
+            _gameObject.SetActive(false);
+            _isLoaded = true;
+            _currentPosition = PictureInPictureAdPosition.Default;
+
+            if (OnAdLoaded != null)
+            {
+                OnAdLoaded.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        public void Show(PictureInPictureAdPosition position)
+        {
+            if (!_isLoaded || _gameObject == null)
+            {
+                Debug.LogWarning("PictureInPictureAd is not loaded.");
+                return;
+            }
+
+            PictureInPictureAdPosition resolvedPosition;
+            if (position == PictureInPictureAdPosition.Default)
+            {
+                resolvedPosition = (_currentPosition != PictureInPictureAdPosition.Default)
+                    ? _currentPosition
+                    : PictureInPictureAdPosition.BottomRight;
+            }
+            else
+            {
+                resolvedPosition = position;
+            }
+
+            _currentPosition = resolvedPosition;
+            AnchorCardToCorner(resolvedPosition);
+
+            _gameObject.SetActive(true);
+
+            if (_simulatorComponent != null)
+            {
+                _simulatorComponent.StartCountdown();
+            }
+
+            if (OnAdShown != null)
+            {
+                OnAdShown.Invoke(this, EventArgs.Empty);
+            }
+
+            if (!_didImpress)
+            {
+                _didImpress = true;
+                if (OnAdDidRecordImpression != null)
+                {
+                    OnAdDidRecordImpression.Invoke(this, EventArgs.Empty);
+                }
+            }
+        }
+
+        public void Hide()
+        {
+            if (_simulatorComponent != null)
+            {
+                _simulatorComponent.StopCountdown();
+            }
+            if (_gameObject != null)
+            {
+                _gameObject.SetActive(false);
+            }
+            if (OnAdHidden != null)
+            {
+                OnAdHidden.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        public void Destroy()
+        {
+            if (_simulatorComponent != null)
+            {
+                _simulatorComponent.StopCountdown();
+            }
+            if (_gameObject != null)
+            {
+                if (Application.isPlaying)
+                {
+                    GameObject.Destroy(_gameObject);
+                }
+                else
+                {
+                    GameObject.DestroyImmediate(_gameObject);
+                }
+                _gameObject = null;
+            }
+            _isLoaded = false;
+            _currentPosition = PictureInPictureAdPosition.Default;
+        }
+
+        public PictureInPictureAdPosition GetAdPosition()
+        {
+            return _currentPosition;
+        }
+
+        public IResponseInfoClient GetResponseInfoClient()
+        {
+            return new ResponseInfoClient();
+        }
+
+        internal void RaiseAdClicked()
+        {
+            if (OnAdClicked != null)
+            {
+                OnAdClicked();
+            }
+            if (OnPaidEvent != null)
+            {
+                OnPaidEvent(new AdValue
+                {
+                    Value = 0,
+                    CurrencyCode = "USD",
+                    Precision = AdValue.PrecisionType.PublisherProvided
+                });
+            }
+            Application.OpenURL("https://google.com");
+        }
+
+        internal enum BadgeType
+        {
+            Countdown3,
+            Countdown2,
+            Countdown1,
+            CloseCross
+        }
+
+        private static readonly Dictionary<BadgeType, Sprite> _badgeSprites = new Dictionary<BadgeType, Sprite>();
+        private static Sprite _roundedCardSprite;
+        private static Sprite _roundedMaskSprite;
+
+        internal static Sprite GetOrCreateRoundedCardSprite(int radius = 12)
+        {
+            if (_roundedCardSprite != null)
+            {
+                return _roundedCardSprite;
+            }
+
+            int size = radius * 2 + 8; // 32x32 texture with 12px corner radius
+            Texture2D texture = new Texture2D(size, size, TextureFormat.RGBA32, false);
+            Color transparent = new Color(0f, 0f, 0f, 0f);
+            Color cardColor = new Color(115f / 255f, 115f / 255f, 115f / 255f, 1f); // #737373
+
+            Color[] pixels = new Color[size * size];
+
+            for (int y = 0; y < size; y++)
+            {
+                for (int x = 0; x < size; x++)
+                {
+                    float cx = (x < radius) ? radius : ((x >= size - radius) ? (size - 1 - radius) : x);
+                    float cy = (y < radius) ? radius : ((y >= size - radius) ? (size - 1 - radius) : y);
+
+                    float dx = x - cx;
+                    float dy = y - cy;
+                    float dist = Mathf.Sqrt(dx * dx + dy * dy);
+
+                    if (dist > radius + 1f)
+                    {
+                        pixels[y * size + x] = transparent;
+                    }
+                    else
+                    {
+                        float alpha = Mathf.Clamp01(radius + 1f - dist);
+                        pixels[y * size + x] = new Color(cardColor.r, cardColor.g, cardColor.b, cardColor.a * alpha);
+                    }
+                }
+            }
+
+            texture.SetPixels(pixels);
+            texture.Apply();
+
+            Vector4 border = new Vector4(radius, radius, radius, radius);
+            _roundedCardSprite = Sprite.Create(texture, new Rect(0, 0, size, size), new Vector2(0.5f, 0.5f), 100f, 0, SpriteMeshType.FullRect, border);
+            return _roundedCardSprite;
+        }
+
+        internal static Sprite GetOrCreateRoundedMaskSprite(int radius = 8)
+        {
+            if (_roundedMaskSprite != null)
+            {
+                return _roundedMaskSprite;
+            }
+
+            int size = radius * 2 + 8; // 24x24 texture with 8px corner radius
+            Texture2D texture = new Texture2D(size, size, TextureFormat.RGBA32, false);
+            Color transparent = new Color(0f, 0f, 0f, 0f);
+
+            Color[] pixels = new Color[size * size];
+
+            for (int y = 0; y < size; y++)
+            {
+                for (int x = 0; x < size; x++)
+                {
+                    float cx = (x < radius) ? radius : ((x >= size - radius) ? (size - 1 - radius) : x);
+                    float cy = (y < radius) ? radius : ((y >= size - radius) ? (size - 1 - radius) : y);
+
+                    float dx = x - cx;
+                    float dy = y - cy;
+                    float dist = Mathf.Sqrt(dx * dx + dy * dy);
+
+                    if (dist > radius + 1f)
+                    {
+                        pixels[y * size + x] = transparent;
+                    }
+                    else
+                    {
+                        float alpha = Mathf.Clamp01(radius + 1f - dist);
+                        pixels[y * size + x] = new Color(1f, 1f, 1f, alpha);
+                    }
+                }
+            }
+
+            texture.SetPixels(pixels);
+            texture.Apply();
+
+            Vector4 border = new Vector4(radius, radius, radius, radius);
+            _roundedMaskSprite = Sprite.Create(texture, new Rect(0, 0, size, size), new Vector2(0.5f, 0.5f), 100f, 0, SpriteMeshType.FullRect, border);
+            return _roundedMaskSprite;
+        }
+
+        internal static Sprite GetOrCreateBadgeSprite(BadgeType type)
+        {
+            Sprite cachedSprite;
+            if (_badgeSprites.TryGetValue(type, out cachedSprite) && cachedSprite != null)
+            {
+                return cachedSprite;
+            }
+
+            int size = 64;
+            Texture2D texture = new Texture2D(size, size, TextureFormat.RGBA32, false);
+            Color transparent = new Color(0f, 0f, 0f, 0f);
+            Color whiteCircle = new Color(1f, 1f, 1f, 0.95f);
+            Color blackInk = new Color(0.1f, 0.1f, 0.1f, 1f);
+
+            float center = (size - 1) / 2f;
+            float radius = (size / 2f) - 2f;
+
+            Color[] pixels = new Color[size * size];
+
+            for (int y = 0; y < size; y++)
+            {
+                for (int x = 0; x < size; x++)
+                {
+                    float dx = x - center;
+                    float dy = y - center;
+                    float dist = Mathf.Sqrt(dx * dx + dy * dy);
+
+                    if (dist > radius + 1f)
+                    {
+                        pixels[y * size + x] = transparent;
+                    }
+                    else
+                    {
+                        float alpha = Mathf.Clamp01(radius + 1f - dist);
+                        Color pixel = new Color(whiteCircle.r, whiteCircle.g, whiteCircle.b, whiteCircle.a * alpha);
+
+                        bool isInk = false;
+                        if (type == BadgeType.CloseCross)
+                        {
+                            float dist1 = Mathf.Abs(dx - dy) / 1.41421356f;
+                            float dist2 = Mathf.Abs(dx + dy) / 1.41421356f;
+                            float maxCoord = Mathf.Max(Mathf.Abs(dx), Mathf.Abs(dy));
+                            float crossWidth = size * 0.08f;
+                            float crossLength = size * 0.28f;
+
+                            if (maxCoord <= crossLength && (dist1 <= crossWidth || dist2 <= crossWidth))
+                            {
+                                float crossDist = Mathf.Min(dist1, dist2);
+                                float crossAlpha = Mathf.Clamp01(crossWidth + 0.5f - crossDist);
+                                pixel = Color.Lerp(pixel, blackInk, crossAlpha * alpha);
+                            }
+                        }
+                        else if (type == BadgeType.Countdown3)
+                        {
+                            if ((dy >= 14 && dy <= 20 && dx >= -8 && dx <= 8) ||
+                                (dy >= 0 && dy <= 18 && dx >= 2 && dx <= 8) ||
+                                (dy >= -3 && dy <= 3 && dx >= -2 && dx <= 8) ||
+                                (dy >= -18 && dy <= 0 && dx >= 2 && dx <= 8) ||
+                                (dy >= -20 && dy <= -14 && dx >= -8 && dx <= 8))
+                            {
+                                isInk = true;
+                            }
+                        }
+                        else if (type == BadgeType.Countdown2)
+                        {
+                            if ((dy >= 14 && dy <= 20 && dx >= -8 && dx <= 8) ||
+                                (dy >= 0 && dy <= 18 && dx >= 2 && dx <= 8) ||
+                                (dy >= -3 && dy <= 3 && dx >= -8 && dx <= 8) ||
+                                (dy >= -18 && dy <= 0 && dx >= -8 && dx <= -2) ||
+                                (dy >= -20 && dy <= -14 && dx >= -8 && dx <= 8))
+                            {
+                                isInk = true;
+                            }
+                        }
+                        else if (type == BadgeType.Countdown1)
+                        {
+                            if ((dy >= -18 && dy <= 20 && dx >= -2 && dx <= 4) ||
+                                (dy >= 10 && dy <= 18 && dx >= -8 && dx <= 0) ||
+                                (dy >= -20 && dy <= -14 && dx >= -8 && dx <= 10))
+                            {
+                                isInk = true;
+                            }
+                        }
+
+                        if (isInk)
+                        {
+                            pixel = Color.Lerp(pixel, blackInk, alpha);
+                        }
+
+                        pixels[y * size + x] = pixel;
+                    }
+                }
+            }
+
+            texture.SetPixels(pixels);
+            texture.Apply();
+            Sprite sprite = Sprite.Create(texture, new Rect(0, 0, size, size), new Vector2(0.5f, 0.5f));
+            _badgeSprites[type] = sprite;
+            return sprite;
+        }
+
+        private void AnchorCardToCorner(PictureInPictureAdPosition position)
+        {
+            if (_cardRect == null)
+            {
+                return;
+            }
+
+            float width = _cardRect.sizeDelta.x;
+            float height = _cardRect.sizeDelta.y;
+            float halfWidth = width / 2f;
+            float halfHeight = height / 2f;
+            float padding = 20f;
+
+            _cardRect.pivot = new Vector2(0.5f, 0.5f);
+
+            switch (position)
+            {
+                case PictureInPictureAdPosition.TopLeft:
+                    _cardRect.anchorMin = new Vector2(0, 1);
+                    _cardRect.anchorMax = new Vector2(0, 1);
+                    _cardRect.anchoredPosition = new Vector2(halfWidth + padding, -(halfHeight + padding));
+                    break;
+                case PictureInPictureAdPosition.TopRight:
+                    _cardRect.anchorMin = new Vector2(1, 1);
+                    _cardRect.anchorMax = new Vector2(1, 1);
+                    _cardRect.anchoredPosition = new Vector2(-(halfWidth + padding), -(halfHeight + padding));
+                    break;
+                case PictureInPictureAdPosition.BottomLeft:
+                    _cardRect.anchorMin = new Vector2(0, 0);
+                    _cardRect.anchorMax = new Vector2(0, 0);
+                    _cardRect.anchoredPosition = new Vector2(halfWidth + padding, halfHeight + padding);
+                    break;
+                case PictureInPictureAdPosition.BottomRight:
+                case PictureInPictureAdPosition.Default:
+                default:
+                    _cardRect.anchorMin = new Vector2(1, 0);
+                    _cardRect.anchorMax = new Vector2(1, 0);
+                    _cardRect.anchoredPosition = new Vector2(-(halfWidth + padding), halfHeight + padding);
+                    break;
+            }
+        }
+    }
+
+    internal class PipSimulatorComponent : MonoBehaviour, IPointerDownHandler, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerClickHandler
+    {
+        public Action<PictureInPictureAdPosition> OnCornerSnapped;
+        private PictureInPictureAdClient _client;
+        private Image _badgeImage;
+        private Button _closeButton;
+        private RectTransform _rectTransform;
+        private Canvas _canvas;
+        private Vector2 _pointerDownPos;
+        private bool _isDragging = false;
+        private Coroutine _countdownCoroutine;
+        private Coroutine _snapCoroutine;
+
+        public void Initialize(PictureInPictureAdClient client, Image badgeImage, Button closeButton)
+        {
+            _client = client;
+            _badgeImage = badgeImage;
+            _closeButton = closeButton;
+            _rectTransform = GetComponent<RectTransform>();
+            _canvas = GetComponentInParent<Canvas>();
+
+            if (_closeButton != null)
+            {
+                _closeButton.onClick.AddListener(() =>
+                {
+                    if (_client != null)
+                    {
+                        _client.Hide();
+                    }
+                });
+            }
+        }
+
+        public void StartCountdown()
+        {
+            StopCountdown();
+            _countdownCoroutine = StartCoroutine(CountdownRoutine());
+        }
+
+        public void StopCountdown()
+        {
+            if (_countdownCoroutine != null)
+            {
+                StopCoroutine(_countdownCoroutine);
+                _countdownCoroutine = null;
+            }
+        }
+
+        private IEnumerator CountdownRoutine()
+        {
+            if (_closeButton != null)
+            {
+                _closeButton.interactable = false;
+            }
+
+            if (_badgeImage != null)
+            {
+                _badgeImage.sprite = PictureInPictureAdClient.GetOrCreateBadgeSprite(PictureInPictureAdClient.BadgeType.Countdown3);
+            }
+            yield return new WaitForSeconds(1f);
+
+            if (_badgeImage != null)
+            {
+                _badgeImage.sprite = PictureInPictureAdClient.GetOrCreateBadgeSprite(PictureInPictureAdClient.BadgeType.Countdown2);
+            }
+            yield return new WaitForSeconds(1f);
+
+            if (_badgeImage != null)
+            {
+                _badgeImage.sprite = PictureInPictureAdClient.GetOrCreateBadgeSprite(PictureInPictureAdClient.BadgeType.Countdown1);
+            }
+            yield return new WaitForSeconds(1f);
+
+            if (_badgeImage != null)
+            {
+                _badgeImage.sprite = PictureInPictureAdClient.GetOrCreateBadgeSprite(PictureInPictureAdClient.BadgeType.CloseCross);
+            }
+            if (_closeButton != null)
+            {
+                _closeButton.interactable = true;
+            }
+            _countdownCoroutine = null;
+        }
+
+        public void OnPointerDown(PointerEventData eventData)
+        {
+            _pointerDownPos = eventData.position;
+            _isDragging = false;
+        }
+
+        public void OnBeginDrag(PointerEventData eventData)
+        {
+            _isDragging = true;
+            if (_snapCoroutine != null)
+            {
+                StopCoroutine(_snapCoroutine);
+                _snapCoroutine = null;
+            }
+        }
+
+        public void OnDrag(PointerEventData eventData)
+        {
+            if (Vector2.Distance(eventData.position, _pointerDownPos) > 10f)
+            {
+                _isDragging = true;
+            }
+
+            if (_rectTransform != null && _canvas != null)
+            {
+                _rectTransform.anchoredPosition += eventData.delta / _canvas.scaleFactor;
+            }
+        }
+
+        public void OnEndDrag(PointerEventData eventData)
+        {
+            if (_rectTransform == null)
+            {
+                return;
+            }
+
+            Vector2 center = _rectTransform.position;
+            float screenMidX = Screen.width / 2f;
+            float screenMidY = Screen.height / 2f;
+
+            PictureInPictureAdPosition targetPosition;
+            if (center.x > screenMidX && center.y < screenMidY)
+            {
+                targetPosition = PictureInPictureAdPosition.BottomRight;
+            }
+            else if (center.x <= screenMidX && center.y < screenMidY)
+            {
+                targetPosition = PictureInPictureAdPosition.BottomLeft;
+            }
+            else if (center.x <= screenMidX && center.y >= screenMidY)
+            {
+                targetPosition = PictureInPictureAdPosition.TopLeft;
+            }
+            else
+            {
+                targetPosition = PictureInPictureAdPosition.TopRight;
+            }
+
+            if (_snapCoroutine != null)
+            {
+                StopCoroutine(_snapCoroutine);
+            }
+            _snapCoroutine = StartCoroutine(SmoothSnapRoutine(targetPosition));
+        }
+
+        private IEnumerator SmoothSnapRoutine(PictureInPictureAdPosition targetPosition)
+        {
+            if (_rectTransform == null)
+            {
+                yield break;
+            }
+
+            float width = _rectTransform.sizeDelta.x;
+            float height = _rectTransform.sizeDelta.y;
+            float halfWidth = width / 2f;
+            float halfHeight = height / 2f;
+            float padding = 20f;
+
+            Vector2 targetAnchorMin;
+            Vector2 targetAnchorMax;
+            Vector2 targetAnchoredPos;
+
+            switch (targetPosition)
+            {
+                case PictureInPictureAdPosition.TopLeft:
+                    targetAnchorMin = new Vector2(0, 1);
+                    targetAnchorMax = new Vector2(0, 1);
+                    targetAnchoredPos = new Vector2(halfWidth + padding, -(halfHeight + padding));
+                    break;
+                case PictureInPictureAdPosition.TopRight:
+                    targetAnchorMin = new Vector2(1, 1);
+                    targetAnchorMax = new Vector2(1, 1);
+                    targetAnchoredPos = new Vector2(-(halfWidth + padding), -(halfHeight + padding));
+                    break;
+                case PictureInPictureAdPosition.BottomLeft:
+                    targetAnchorMin = new Vector2(0, 0);
+                    targetAnchorMax = new Vector2(0, 0);
+                    targetAnchoredPos = new Vector2(halfWidth + padding, halfHeight + padding);
+                    break;
+                case PictureInPictureAdPosition.BottomRight:
+                case PictureInPictureAdPosition.Default:
+                default:
+                    targetAnchorMin = new Vector2(1, 0);
+                    targetAnchorMax = new Vector2(1, 0);
+                    targetAnchoredPos = new Vector2(-(halfWidth + padding), halfHeight + padding);
+                    break;
+            }
+
+            // Convert current world position to target anchor local coordinate
+            Vector3 worldPos = _rectTransform.position;
+            _rectTransform.anchorMin = targetAnchorMin;
+            _rectTransform.anchorMax = targetAnchorMax;
+            _rectTransform.position = worldPos;
+
+            Vector2 startPos = _rectTransform.anchoredPosition;
+            float duration = 0.5f;
+            float elapsed = 0f;
+
+            while (elapsed < duration)
+            {
+                elapsed += Time.unscaledDeltaTime;
+                float t = Mathf.Clamp01(elapsed / duration);
+                // S-curve smoothstep for natural, gradual deceleration
+                float smoothT = Mathf.SmoothStep(0f, 1f, t);
+                _rectTransform.anchoredPosition = Vector2.Lerp(startPos, targetAnchoredPos, smoothT);
+                yield return null;
+            }
+
+            _rectTransform.anchoredPosition = targetAnchoredPos;
+            _snapCoroutine = null;
+
+            if (OnCornerSnapped != null)
+            {
+                OnCornerSnapped(targetPosition);
+            }
+        }
+
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            // Do not fire ad click if user was dragging or clicked on the close button
+            if (_isDragging)
+            {
+                return;
+            }
+
+            if (_closeButton != null && eventData.pointerPressRaycast.gameObject == _closeButton.gameObject)
+            {
+                return;
+            }
+
+            if (_client != null)
+            {
+                _client.RaiseAdClicked();
+            }
+        }
+    }
+}
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/GoogleMobileAdsClientFactory.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/GoogleMobileAdsClientFactory.cs
index 449c4b60b..9427fb4c2 100644
--- a/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/GoogleMobileAdsClientFactory.cs
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/GoogleMobileAdsClientFactory.cs
@@ -129,6 +129,15 @@ public IMobileAdsClient MobileAdsInstance() {
                                           " on non-iOS runtime");
     }
 
+    public IPictureInPictureAdClient BuildPictureInPictureAdClient() {
+      if (Application.platform == RuntimePlatform.IPhonePlayer)
+      {
+        return new GoogleMobileAds.iOS.PictureInPictureAdClient();
+      }
+      throw new InvalidOperationException(@"Called " + MethodBase.GetCurrentMethod().Name +
+                                          " on non-iOS runtime");
+    }
+
 #if GMA_PREVIEW_FEATURES
 
     public IAppOpenAdPreloaderClient BuildAppOpenAdPreloaderClient() {
diff --git a/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/PictureInPictureAdClient.cs b/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/PictureInPictureAdClient.cs
new file mode 100644
index 000000000..281489808
--- /dev/null
+++ b/source/plugin/Assets/GoogleMobileAds/Platforms/iOS/PictureInPictureAdClient.cs
@@ -0,0 +1,68 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using GoogleMobileAds.Api;
+using GoogleMobileAds.Common;
+
+namespace GoogleMobileAds.iOS
+{
+    public class PictureInPictureAdClient : IPictureInPictureAdClient
+    {
+        public event EventHandler<EventArgs> OnAdLoaded;
+        public event EventHandler<LoadAdErrorClientEventArgs> OnAdFailedToLoad;
+        public event EventHandler<EventArgs> OnAdShown;
+        public event EventHandler<EventArgs> OnAdHidden;
+        public event EventHandler<EventArgs> OnAdDidRecordImpression;
+        public event Action OnAdClicked;
+        public event EventHandler<EventArgs> OnAdDidPresentFullScreenContent;
+        public event EventHandler<EventArgs> OnAdDidDismissFullScreenContent;
+        public event Action<AdValue> OnPaidEvent;
+
+        public void CreatePictureInPictureAd()
+        {
+            // No-op for iOS dummy client.
+        }
+
+        public void LoadAd(string adUnitId, AdRequest request)
+        {
+            // No-op for iOS dummy client.
+        }
+
+        public void Show(PictureInPictureAdPosition position)
+        {
+            // No-op for iOS dummy client.
+        }
+
+        public void Hide()
+        {
+            // No-op for iOS dummy client.
+        }
+
+        public void Destroy()
+        {
+            // No-op for iOS dummy client.
+        }
+
+        public PictureInPictureAdPosition GetAdPosition()
+        {
+            return PictureInPictureAdPosition.Default;
+        }
+
+        public IResponseInfoClient GetResponseInfoClient()
+        {
+            return null;
+        }
+    }
+}
diff --git a/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/AdWrapper.java b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/AdWrapper.java
index 7808afdc1..b997a8b30 100644
--- a/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/AdWrapper.java
+++ b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/AdWrapper.java
@@ -6,6 +6,8 @@
 import com.google.android.libraries.ads.mobile.sdk.common.AdLoadCallback;
 import com.google.android.libraries.ads.mobile.sdk.common.AdRequest;
 import com.google.android.libraries.ads.mobile.sdk.interstitial.InterstitialAd;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAd;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdRequest;
 import com.google.android.libraries.ads.mobile.sdk.rewarded.RewardedAd;
 import com.google.android.libraries.ads.mobile.sdk.rewardedinterstitial.RewardedInterstitialAd;
 
@@ -67,4 +69,20 @@ public static AdWrapper<RewardedAd> forRewarded() {
   public static AdWrapper<RewardedInterstitialAd> forRewardedInterstitial() {
     return new AdWrapper<>(RewardedInterstitialAd::load);
   }
+
+  /** Creates a new AdWrapper for loading PictureInPictureAds. */
+  public static AdWrapper<PictureInPictureAd> forPictureInPicture() {
+    return new AdWrapper<>(
+        new AdLoader<PictureInPictureAd>() {
+          @Override
+          public void load(AdRequest adRequest, AdLoadCallback<PictureInPictureAd> callback) {
+            if (adRequest instanceof PictureInPictureAdRequest) {
+              PictureInPictureAd.load((PictureInPictureAdRequest) adRequest, callback);
+            } else {
+              throw new IllegalArgumentException(
+                  "AdRequest must be of type PictureInPictureAdRequest for PiP Ads");
+            }
+          }
+        });
+  }
 }
diff --git a/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/UnityPictureInPictureAd.java b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/UnityPictureInPictureAd.java
new file mode 100644
index 000000000..e62028c3d
--- /dev/null
+++ b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/UnityPictureInPictureAd.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2026 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.unity.ads.nextgen;
+
+import android.app.Activity;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.libraries.ads.mobile.sdk.common.AdLoadCallback;
+import com.google.android.libraries.ads.mobile.sdk.common.AdRequest;
+import com.google.android.libraries.ads.mobile.sdk.common.AdValue;
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError;
+import com.google.android.libraries.ads.mobile.sdk.common.ResponseInfo;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAd;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdEventCallback;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdOptions;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdPosition;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdRequest;
+
+/** Native Java implementation for Picture-in-Picture Ads in the Google Mobile Ads Unity plugin. */
+public class UnityPictureInPictureAd {
+
+  private static final String LOG_TAG = "GoogleMobileAds";
+
+  private final Activity activity;
+  private final UnityPictureInPictureAdCallback callback;
+  private final AdWrapper<PictureInPictureAd> adWrapper;
+  @Nullable private PictureInPictureAd pipAd;
+
+  public UnityPictureInPictureAd(Activity activity, UnityPictureInPictureAdCallback callback) {
+    this(activity, callback, AdWrapper.forPictureInPicture());
+  }
+
+  @VisibleForTesting
+  UnityPictureInPictureAd(
+      Activity activity,
+      UnityPictureInPictureAdCallback callback,
+      AdWrapper<PictureInPictureAd> adWrapper) {
+    this.activity = activity;
+    this.callback = callback;
+    this.adWrapper = adWrapper;
+  }
+
+  /**
+   * Loads a Picture-in-Picture ad on the UI thread.
+   *
+   * @param adUnitId The ad unit ID to load.
+   * @param adRequest The native AdRequest object.
+   */
+  public void load(String adUnitId, AdRequest adRequest) {
+    activity.runOnUiThread(
+        () -> {
+          try {
+            PictureInPictureAdRequest pipRequest =
+                new PictureInPictureAdRequest.Builder(adUnitId).build();
+
+            adWrapper.load(
+                pipRequest,
+                new AdLoadCallback<PictureInPictureAd>() {
+                  @Override
+                  public void onAdLoaded(@NonNull PictureInPictureAd ad) {
+                    pipAd = ad;
+                    pipAd.setAdEventCallback(
+                        new PictureInPictureAdEventCallback() {
+                          @Override
+                          public void onAdShown() {
+                            if (callback != null) {
+                              callback.onAdShown();
+                            }
+                          }
+
+                          @Override
+                          public void onAdHidden() {
+                            if (callback != null) {
+                              callback.onAdHidden();
+                            }
+                          }
+
+                          @Override
+                          public void onAdClicked() {
+                            if (callback != null) {
+                              callback.onAdClicked();
+                            }
+                          }
+
+                          @Override
+                          public void onAdImpression() {
+                            if (callback != null) {
+                              callback.onAdImpression();
+                            }
+                          }
+
+                          @Override
+                          public void onAdShowedFullScreenContent() {
+                            if (callback != null) {
+                              callback.onAdShowedFullScreenContent();
+                            }
+                          }
+
+                          @Override
+                          public void onAdDismissedFullScreenContent() {
+                            if (callback != null) {
+                              callback.onAdDismissedFullScreenContent();
+                            }
+                          }
+
+                          @Override
+                          public void onAdPaid(@NonNull AdValue adValue) {
+                            if (callback != null) {
+                              callback.onPaidEvent(
+                                  Util.getAdValuePrecisionType(adValue.getPrecisionType()),
+                                  adValue.getValueMicros(),
+                                  adValue.getCurrencyCode());
+                            }
+                          }
+                        });
+
+                    if (callback != null) {
+                      callback.onAdLoaded();
+                    }
+                  }
+
+                  @Override
+                  public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                    if (callback != null) {
+                      callback.onAdFailedToLoad(loadAdError);
+                    }
+                  }
+                });
+          } catch (Throwable t) {
+            Log.e(LOG_TAG, "Failed to load PictureInPictureAd: " + t, t);
+            if (callback != null) {
+              callback.onAdFailedToLoad(
+                  new LoadAdError(
+                      LoadAdError.ErrorCode.INTERNAL_ERROR,
+                      t.getMessage() != null ? t.getMessage() : t.toString(),
+                      null));
+            }
+          }
+        });
+  }
+
+  /**
+   * Shows the Picture-in-Picture ad at the given corner position.
+   *
+   * @param positionOrdinal 0=BOTTOM_RIGHT, 1=BOTTOM_LEFT, 2=TOP_LEFT, 3=TOP_RIGHT.
+   */
+  public void show(int positionOrdinal) {
+    activity.runOnUiThread(
+        () -> {
+          if (pipAd == null) {
+            Log.e(LOG_TAG, "Failed to show PictureInPictureAd: ad is null.");
+            return;
+          }
+          PictureInPictureAdPosition position;
+          switch (positionOrdinal) {
+            case 1:
+              position = PictureInPictureAdPosition.BOTTOM_RIGHT;
+              break;
+            case 2:
+              position = PictureInPictureAdPosition.BOTTOM_LEFT;
+              break;
+            case 3:
+              position = PictureInPictureAdPosition.TOP_LEFT;
+              break;
+            case 4:
+              position = PictureInPictureAdPosition.TOP_RIGHT;
+              break;
+            case 0:
+            default:
+              position = PictureInPictureAdPosition.DEFAULT;
+              break;
+          }
+          PictureInPictureAdOptions options =
+              new PictureInPictureAdOptions.Builder().setPosition(position).build();
+          pipAd.show(activity, options);
+        });
+  }
+
+  /** Hides the Picture-in-Picture ad. */
+  public void hide() {
+    activity.runOnUiThread(
+        () -> {
+          if (pipAd != null) {
+            pipAd.hide();
+          }
+        });
+  }
+
+  /** Destroys the Picture-in-Picture ad and cleans up references. */
+  public void destroy() {
+    activity.runOnUiThread(
+        () -> {
+          if (pipAd != null) {
+            pipAd.destroy();
+            pipAd = null;
+          }
+        });
+  }
+
+  /** Returns the current or last known position ordinal (0=DEFAULT, 1=BOTTOM_RIGHT, etc.). */
+  public int getAdPosition() {
+    if (pipAd == null) {
+      return 0;
+    }
+    PictureInPictureAdPosition position = pipAd.getPosition();
+    if (position == null) {
+      return 0;
+    }
+    switch (position) {
+      case DEFAULT:
+        return 0;
+      case BOTTOM_RIGHT:
+        return 1;
+      case BOTTOM_LEFT:
+        return 2;
+      case TOP_LEFT:
+        return 3;
+      case TOP_RIGHT:
+        return 4;
+    }
+    return 0;
+  }
+
+  /** Returns ResponseInfo for the loaded ad, if available. */
+  @Nullable
+  public ResponseInfo getResponseInfo() {
+    return pipAd != null ? pipAd.getResponseInfo() : null;
+  }
+}
diff --git a/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/UnityPictureInPictureAdCallback.java b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/UnityPictureInPictureAdCallback.java
new file mode 100644
index 000000000..1b7816a56
--- /dev/null
+++ b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/main/java/com/google/unity/ads/nextgen/UnityPictureInPictureAdCallback.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2026 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.unity.ads.nextgen;
+
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError;
+
+/**
+ * An interface form of {@link UnityPictureInPictureAdCallback} that can be implemented via {@code
+ * AndroidJavaProxy} in Unity to receive ad events synchronously.
+ */
+public interface UnityPictureInPictureAdCallback extends UnityPaidEventListener {
+
+  /** Called when the picture in picture ad is loaded. */
+  void onAdLoaded();
+
+  /** Called when the picture in picture ad fails to load. */
+  void onAdFailedToLoad(LoadAdError error);
+
+  /** Called when the picture in picture ad is displayed on the screen. */
+  void onAdShown();
+
+  /** Called when the picture in picture ad is hidden from the screen. */
+  void onAdHidden();
+
+  /** Called when the picture in picture ad records an impression. */
+  void onAdImpression();
+
+  /** Called when the picture in picture ad records a click. */
+  void onAdClicked();
+
+  /** Called when the picture in picture ad opens an overlay that covers the screen. */
+  void onAdShowedFullScreenContent();
+
+  /** Called when the picture in picture ad dismisses an overlay that it previously showed. */
+  void onAdDismissedFullScreenContent();
+}
diff --git a/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/test/java/com/google/unity/ads/nextgen/UnityPictureInPictureAdTest.java b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/test/java/com/google/unity/ads/nextgen/UnityPictureInPictureAdTest.java
new file mode 100644
index 000000000..a72c5c694
--- /dev/null
+++ b/source/plugin/Assets/Plugins/Android/GoogleMobileAdsPlugin.androidlib/src/test/java/com/google/unity/ads/nextgen/UnityPictureInPictureAdTest.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright (C) 2026 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.unity.ads.nextgen;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.Activity;
+import android.os.Bundle;
+import com.google.android.libraries.ads.mobile.sdk.common.AdLoadCallback;
+import com.google.android.libraries.ads.mobile.sdk.common.AdRequest;
+import com.google.android.libraries.ads.mobile.sdk.common.AdValue;
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError;
+import com.google.android.libraries.ads.mobile.sdk.common.PrecisionType;
+import com.google.android.libraries.ads.mobile.sdk.common.ResponseInfo;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAd;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdEventCallback;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdOptions;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdPosition;
+import com.google.android.libraries.ads.mobile.sdk.pip.PictureInPictureAdRequest;
+import java.util.ArrayList;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+
+/** Unit tests for {@link UnityPictureInPictureAd} and {@link UnityPictureInPictureAdCallback}. */
+@RunWith(RobolectricTestRunner.class)
+public final class UnityPictureInPictureAdTest {
+
+  private static final String AD_UNIT_ID = "ca-app-pub-3940256099942544/6300978111";
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private Activity activity;
+  @Mock private UnityPictureInPictureAdCallback mockCallback;
+  @Mock private PictureInPictureAd mockPipAd;
+  @Mock private AdWrapper<PictureInPictureAd> mockAdWrapper;
+  @Mock private AdRequest mockAdRequest;
+
+  @Captor private ArgumentCaptor<PictureInPictureAdRequest> adRequestCaptor;
+  @Captor private ArgumentCaptor<AdLoadCallback<PictureInPictureAd>> adLoadCallbackCaptor;
+  @Captor private ArgumentCaptor<PictureInPictureAdEventCallback> adEventCallbackCaptor;
+  @Captor private ArgumentCaptor<PictureInPictureAdOptions> adOptionsCaptor;
+
+  private UnityPictureInPictureAd unityPictureInPictureAd;
+
+  @Before
+  public void setUp() {
+    activity = Robolectric.buildActivity(Activity.class).create().get();
+    unityPictureInPictureAd = new UnityPictureInPictureAd(activity, mockCallback, mockAdWrapper);
+  }
+
+  @Test
+  public void testPublicConstructor_createsInstance() {
+    UnityPictureInPictureAd ad = new UnityPictureInPictureAd(activity, mockCallback);
+    assertThat(ad).isNotNull();
+  }
+
+  @Test
+  public void testLoad_onAdLoaded_invokesCallback() {
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+
+    verify(mockAdWrapper).load(adRequestCaptor.capture(), adLoadCallbackCaptor.capture());
+    assertThat(adRequestCaptor.getValue().getAdUnitId()).isEqualTo(AD_UNIT_ID);
+
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+    verify(mockCallback).onAdLoaded();
+    verify(mockPipAd).setAdEventCallback(any());
+  }
+
+  @Test
+  public void testLoad_onAdFailedToLoad_invokesCallback() {
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+
+    verify(mockAdWrapper).load(adRequestCaptor.capture(), adLoadCallbackCaptor.capture());
+    LoadAdError loadAdError =
+        new LoadAdError(LoadAdError.ErrorCode.INTERNAL_ERROR, "error message", null);
+    adLoadCallbackCaptor.getValue().onAdFailedToLoad(loadAdError);
+
+    verify(mockCallback).onAdFailedToLoad(loadAdError);
+    verify(mockCallback, never()).onAdLoaded();
+  }
+
+  @Test
+  public void testAdEventCallbacks_allEventsTriggered() {
+    // Load the ad first
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    verify(mockPipAd).setAdEventCallback(adEventCallbackCaptor.capture());
+    PictureInPictureAdEventCallback eventCallback = adEventCallbackCaptor.getValue();
+
+    // Verify onAdShown
+    eventCallback.onAdShown();
+    verify(mockCallback).onAdShown();
+
+    // Verify onAdHidden
+    eventCallback.onAdHidden();
+    verify(mockCallback).onAdHidden();
+
+    // Verify onAdClicked
+    eventCallback.onAdClicked();
+    verify(mockCallback).onAdClicked();
+
+    // Verify onAdImpression
+    eventCallback.onAdImpression();
+    verify(mockCallback).onAdImpression();
+
+    // Verify onAdShowedFullScreenContent
+    eventCallback.onAdShowedFullScreenContent();
+    verify(mockCallback).onAdShowedFullScreenContent();
+
+    // Verify onAdDismissedFullScreenContent
+    eventCallback.onAdDismissedFullScreenContent();
+    verify(mockCallback).onAdDismissedFullScreenContent();
+
+    // Verify onAdPaid
+    PrecisionType precisionType = PrecisionType.PRECISE;
+    long valueMicros = 1500000L;
+    String currencyCode = "USD";
+    eventCallback.onAdPaid(new AdValue(precisionType, valueMicros, currencyCode));
+    verify(mockCallback)
+        .onPaidEvent(Util.getAdValuePrecisionType(precisionType), valueMicros, currencyCode);
+  }
+
+  @Test
+  public void testShow_whenAdNotLoaded_doesNotThrow() {
+    unityPictureInPictureAd.show(0);
+    verify(mockPipAd, never()).show(any(), any());
+  }
+
+  @Test
+  public void testShow_defaultPosition_passesDefaultOptions() {
+    // Load the ad
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    // Call show(0) for Default
+    unityPictureInPictureAd.show(0);
+
+    verify(mockPipAd).show(eq(activity), adOptionsCaptor.capture());
+    assertThat(adOptionsCaptor.getValue().getPosition())
+        .isEqualTo(PictureInPictureAdPosition.DEFAULT);
+  }
+
+  @Test
+  public void testShow_explicitPositions_passesCorrectOptions() {
+    // Load the ad
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    // Test position 1 -> BOTTOM_RIGHT
+    unityPictureInPictureAd.show(1);
+    verify(mockPipAd).show(eq(activity), adOptionsCaptor.capture());
+    assertThat(adOptionsCaptor.getValue().getPosition())
+        .isEqualTo(PictureInPictureAdPosition.BOTTOM_RIGHT);
+
+    // Test position 2 -> BOTTOM_LEFT
+    unityPictureInPictureAd.show(2);
+    verify(mockPipAd, Mockito.times(2)).show(eq(activity), adOptionsCaptor.capture());
+    assertThat(adOptionsCaptor.getValue().getPosition())
+        .isEqualTo(PictureInPictureAdPosition.BOTTOM_LEFT);
+
+    // Test position 3 -> TOP_LEFT
+    unityPictureInPictureAd.show(3);
+    verify(mockPipAd, Mockito.times(3)).show(eq(activity), adOptionsCaptor.capture());
+    assertThat(adOptionsCaptor.getValue().getPosition())
+        .isEqualTo(PictureInPictureAdPosition.TOP_LEFT);
+
+    // Test position 4 -> TOP_RIGHT
+    unityPictureInPictureAd.show(4);
+    verify(mockPipAd, Mockito.times(4)).show(eq(activity), adOptionsCaptor.capture());
+    assertThat(adOptionsCaptor.getValue().getPosition())
+        .isEqualTo(PictureInPictureAdPosition.TOP_RIGHT);
+  }
+
+  @Test
+  public void testHide_whenAdLoaded_callsPipAdHide() {
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    unityPictureInPictureAd.hide();
+    verify(mockPipAd).hide();
+  }
+
+  @Test
+  public void testHide_whenAdNotLoaded_doesNotThrow() {
+    unityPictureInPictureAd.hide();
+    verify(mockPipAd, never()).hide();
+  }
+
+  @Test
+  public void testDestroy_whenAdLoaded_destroysAndCleansUp() {
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    unityPictureInPictureAd.destroy();
+    verify(mockPipAd).destroy();
+
+    // Verify subsequent show or hide does not invoke pipAd
+    unityPictureInPictureAd.show(0);
+    verify(mockPipAd, never()).show(any(), any());
+  }
+
+  @Test
+  public void testGetAdPosition_whenAdNotLoaded_returnsDefaultZero() {
+    assertThat(unityPictureInPictureAd.getAdPosition()).isEqualTo(0);
+  }
+
+  @Test
+  public void testGetAdPosition_whenAdLoaded_mapsPositionsCorrectly() {
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    // DEFAULT -> 0
+    when(mockPipAd.getPosition()).thenReturn(PictureInPictureAdPosition.DEFAULT);
+    assertThat(unityPictureInPictureAd.getAdPosition()).isEqualTo(0);
+
+    // BOTTOM_RIGHT -> 1
+    when(mockPipAd.getPosition()).thenReturn(PictureInPictureAdPosition.BOTTOM_RIGHT);
+    assertThat(unityPictureInPictureAd.getAdPosition()).isEqualTo(1);
+
+    // BOTTOM_LEFT -> 2
+    when(mockPipAd.getPosition()).thenReturn(PictureInPictureAdPosition.BOTTOM_LEFT);
+    assertThat(unityPictureInPictureAd.getAdPosition()).isEqualTo(2);
+
+    // TOP_LEFT -> 3
+    when(mockPipAd.getPosition()).thenReturn(PictureInPictureAdPosition.TOP_LEFT);
+    assertThat(unityPictureInPictureAd.getAdPosition()).isEqualTo(3);
+
+    // TOP_RIGHT -> 4
+    when(mockPipAd.getPosition()).thenReturn(PictureInPictureAdPosition.TOP_RIGHT);
+    assertThat(unityPictureInPictureAd.getAdPosition()).isEqualTo(4);
+  }
+
+  @Test
+  public void testGetResponseInfo_whenAdNotLoaded_returnsNull() {
+    assertThat(unityPictureInPictureAd.getResponseInfo()).isNull();
+  }
+
+  @Test
+  public void testGetResponseInfo_whenAdLoaded_returnsResponseInfo() {
+    ResponseInfo responseInfo =
+        new ResponseInfo("AdapterName", "responseId", new Bundle(), null, new ArrayList<>());
+    when(mockPipAd.getResponseInfo()).thenReturn(responseInfo);
+
+    unityPictureInPictureAd.load(AD_UNIT_ID, mockAdRequest);
+    verify(mockAdWrapper).load(any(), adLoadCallbackCaptor.capture());
+    adLoadCallbackCaptor.getValue().onAdLoaded(mockPipAd);
+
+    ResponseInfo actualResponseInfo = unityPictureInPictureAd.getResponseInfo();
+    verify(mockPipAd).getResponseInfo();
+    assertThat(actualResponseInfo).isEqualTo(responseInfo);
+  }
+}