| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/browser/screen_orientation/screen_orientation_provider_android.h" |
| |
| #include "content/browser/android/content_view_core_impl.h" |
| #include "content/browser/screen_orientation/screen_orientation_dispatcher_host.h" |
| #include "content/browser/web_contents/web_contents_impl.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/browser/render_widget_host.h" |
| #include "jni/ScreenOrientationProvider_jni.h" |
| #include "third_party/WebKit/public/platform/WebLockOrientationError.h" |
| #include "third_party/WebKit/public/platform/WebScreenInfo.h" |
| |
| namespace content { |
| |
| ScreenOrientationProviderAndroid::LockInformation::LockInformation( |
| int request_id, blink::WebScreenOrientationLockType lock) |
| : request_id(request_id), lock(lock) {} |
| |
| ScreenOrientationProviderAndroid::ScreenOrientationProviderAndroid( |
| ScreenOrientationDispatcherHost* dispatcher, |
| WebContents* web_contents) |
| : ScreenOrientationProvider(), |
| WebContentsObserver(web_contents), |
| dispatcher_(dispatcher), |
| lock_applied_(false), |
| pending_lock_(NULL) { |
| } |
| |
| ScreenOrientationProviderAndroid::~ScreenOrientationProviderAndroid() { |
| if (pending_lock_) |
| delete pending_lock_; |
| } |
| |
| WebContentsImpl* ScreenOrientationProviderAndroid::web_contents_impl() { |
| return static_cast<WebContentsImpl*>(web_contents()); |
| } |
| |
| // static |
| bool ScreenOrientationProviderAndroid::Register(JNIEnv* env) { |
| return RegisterNativesImpl(env); |
| } |
| |
| void ScreenOrientationProviderAndroid::LockOrientation( |
| int request_id, |
| blink::WebScreenOrientationLockType lock_orientation) { |
| ContentViewCoreImpl* cvc = |
| ContentViewCoreImpl::FromWebContents(web_contents()); |
| bool fullscreen_required = cvc ? cvc->IsFullscreenRequiredForOrientationLock() |
| : true; |
| |
| if (fullscreen_required && |
| !web_contents_impl()->IsFullscreenForCurrentTab()) { |
| dispatcher_->NotifyLockError( |
| request_id, |
| blink::WebLockOrientationErrorFullScreenRequired); |
| return; |
| } |
| |
| if (lock_orientation == blink::WebScreenOrientationLockNatural) { |
| lock_orientation = GetNaturalLockType(); |
| if (lock_orientation == blink::WebScreenOrientationLockDefault) { |
| // We are in a broken state, let's pretend we got canceled. |
| dispatcher_->NotifyLockError(request_id, |
| blink::WebLockOrientationErrorCanceled); |
| return; |
| } |
| } |
| |
| lock_applied_ = true; |
| Java_ScreenOrientationProvider_lockOrientation( |
| base::android::AttachCurrentThread(), lock_orientation); |
| |
| // If two calls happen close to each other, Android will ignore the first. |
| if (pending_lock_) { |
| delete pending_lock_; |
| pending_lock_ = NULL; |
| } |
| |
| // If the orientation we are locking to matches the current orientation, we |
| // should succeed immediately. |
| if (LockMatchesCurrentOrientation(lock_orientation)) { |
| dispatcher_->NotifyLockSuccess(request_id); |
| return; |
| } |
| |
| pending_lock_ = new LockInformation(request_id, lock_orientation); |
| } |
| |
| void ScreenOrientationProviderAndroid::UnlockOrientation() { |
| if (!lock_applied_) |
| return; |
| |
| Java_ScreenOrientationProvider_unlockOrientation( |
| base::android::AttachCurrentThread()); |
| lock_applied_ = false; |
| } |
| |
| void ScreenOrientationProviderAndroid::OnOrientationChange() { |
| if (!pending_lock_) |
| return; |
| |
| if (LockMatchesCurrentOrientation(pending_lock_->lock)) { |
| dispatcher_->NotifyLockSuccess(pending_lock_->request_id); |
| delete pending_lock_; |
| pending_lock_ = NULL; |
| } |
| } |
| |
| void ScreenOrientationProviderAndroid::DidToggleFullscreenModeForTab( |
| bool entered_fullscreen) { |
| if (!lock_applied_) |
| return; |
| |
| // If fullscreen is not required in order to lock orientation, don't unlock |
| // when fullscreen state changes. |
| ContentViewCoreImpl* cvc = |
| ContentViewCoreImpl::FromWebContents(web_contents()); |
| if (cvc && !cvc->IsFullscreenRequiredForOrientationLock()) |
| return; |
| |
| DCHECK(!entered_fullscreen); |
| UnlockOrientation(); |
| } |
| |
| bool ScreenOrientationProviderAndroid::LockMatchesCurrentOrientation( |
| blink::WebScreenOrientationLockType lock_orientation) { |
| if (!web_contents()->GetRenderViewHost()) |
| return false; |
| |
| RenderWidgetHost* rwh = web_contents()->GetRenderViewHost(); |
| blink::WebScreenInfo screen_info; |
| rwh->GetWebScreenInfo(&screen_info); |
| |
| switch (lock_orientation) { |
| case blink::WebScreenOrientationLockPortraitPrimary: |
| return screen_info.orientationType == |
| blink::WebScreenOrientationPortraitPrimary; |
| case blink::WebScreenOrientationLockPortraitSecondary: |
| return screen_info.orientationType == |
| blink::WebScreenOrientationPortraitSecondary; |
| case blink::WebScreenOrientationLockLandscapePrimary: |
| return screen_info.orientationType == |
| blink::WebScreenOrientationLandscapePrimary; |
| case blink::WebScreenOrientationLockLandscapeSecondary: |
| return screen_info.orientationType == |
| blink::WebScreenOrientationLandscapeSecondary; |
| case blink::WebScreenOrientationLockLandscape: |
| return screen_info.orientationType == |
| blink::WebScreenOrientationLandscapePrimary || |
| screen_info.orientationType == |
| blink::WebScreenOrientationLandscapeSecondary; |
| case blink::WebScreenOrientationLockPortrait: |
| return screen_info.orientationType == |
| blink::WebScreenOrientationPortraitPrimary || |
| screen_info.orientationType == |
| blink::WebScreenOrientationPortraitSecondary; |
| case blink::WebScreenOrientationLockAny: |
| return true; |
| case blink::WebScreenOrientationLockNatural: |
| case blink::WebScreenOrientationLockDefault: |
| NOTREACHED(); |
| return false; |
| } |
| |
| NOTREACHED(); |
| return false; |
| } |
| |
| blink::WebScreenOrientationLockType |
| ScreenOrientationProviderAndroid::GetNaturalLockType() const { |
| if (!web_contents()->GetRenderViewHost()) |
| return blink::WebScreenOrientationLockDefault; |
| |
| RenderWidgetHost* rwh = web_contents()->GetRenderViewHost(); |
| blink::WebScreenInfo screen_info; |
| rwh->GetWebScreenInfo(&screen_info); |
| |
| switch (screen_info.orientationType) { |
| case blink::WebScreenOrientationPortraitPrimary: |
| case blink::WebScreenOrientationPortraitSecondary: |
| if (screen_info.orientationAngle == 0 || |
| screen_info.orientationAngle == 180) { |
| return blink::WebScreenOrientationLockPortraitPrimary; |
| } |
| return blink::WebScreenOrientationLockLandscapePrimary; |
| case blink::WebScreenOrientationLandscapePrimary: |
| case blink::WebScreenOrientationLandscapeSecondary: |
| if (screen_info.orientationAngle == 0 || |
| screen_info.orientationAngle == 180) { |
| return blink::WebScreenOrientationLockLandscapePrimary; |
| } |
| return blink::WebScreenOrientationLockPortraitPrimary; |
| case blink::WebScreenOrientationUndefined: |
| NOTREACHED(); |
| return blink::WebScreenOrientationLockDefault; |
| } |
| |
| NOTREACHED(); |
| return blink::WebScreenOrientationLockDefault; |
| } |
| |
| // static |
| void ScreenOrientationProviderAndroid::StartAccurateListening() { |
| Java_ScreenOrientationProvider_startAccurateListening( |
| base::android::AttachCurrentThread()); |
| } |
| |
| // static |
| void ScreenOrientationProviderAndroid::StopAccurateListening() { |
| Java_ScreenOrientationProvider_stopAccurateListening( |
| base::android::AttachCurrentThread()); |
| } |
| |
| // static |
| ScreenOrientationProvider* ScreenOrientationProvider::Create( |
| ScreenOrientationDispatcherHost* dispatcher, |
| WebContents* web_contents) { |
| return new ScreenOrientationProviderAndroid(dispatcher, web_contents); |
| } |
| |
| } // namespace content |