blob: 2fd2ef4d6b61cbb97efb6449061767652b4c956e [file] [log] [blame]
/*
* Copyright 2008, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "PluginWidgetAndroid.h"
#if ENABLE(TOUCH_EVENTS)
#include "ChromeClient.h"
#endif
#include "Document.h"
#include "Element.h"
#include "Frame.h"
#include "Page.h"
#include "PluginPackage.h"
#include "PluginView.h"
#include "PluginWidgetAndroid.h"
#include "ScrollView.h"
#include "SkANP.h"
#include "SkFlipPixelRef.h"
#include "SkString.h"
#include "SkTime.h"
#include "WebViewCore.h"
#include <JNIUtility.h>
//#define PLUGIN_DEBUG_LOCAL // controls the printing of log messages
#define DEBUG_EVENTS 0 // logs event contents, return value, and processing time
#define DEBUG_VISIBLE_RECTS 0 // temporary debug printfs and fixes
#define MAX( a, b ) ( ((a) > (b)) ? (a) : (b) )
// this include statement must follow the declaration of PLUGIN_DEBUG_LOCAL
#include "PluginDebugAndroid.h"
PluginWidgetAndroid::PluginWidgetAndroid(WebCore::PluginView* view)
: m_pluginView(view) {
m_flipPixelRef = NULL;
m_core = NULL;
m_drawingModel = kBitmap_ANPDrawingModel;
m_eventFlags = 0;
m_pluginWindow = NULL;
m_requestedVisibleRectCount = 0;
m_requestedVisibleRect.setEmpty();
m_visibleDocRect.setEmpty();
m_pluginBounds.setEmpty();
m_hasFocus = false;
m_isFullScreen = false;
m_visible = false;
m_cachedZoomLevel = 0;
m_embeddedView = NULL;
m_embeddedViewAttached = false;
m_acceptEvents = false;
m_isSurfaceClippedOut = false;
m_layer = 0;
m_powerState = kDefault_ANPPowerState;
m_fullScreenOrientation = -1;
m_drawEventDelayed = false;
}
PluginWidgetAndroid::~PluginWidgetAndroid() {
PLUGIN_LOG("%p Deleting Plugin", m_pluginView->instance());
m_acceptEvents = false;
if (m_core) {
setPowerState(kDefault_ANPPowerState);
m_core->removePlugin(this);
if (m_isFullScreen) {
exitFullScreen(true);
}
if (m_embeddedView) {
m_core->destroySurface(m_embeddedView);
}
}
// cleanup any remaining JNI References
JNIEnv* env = JSC::Bindings::getJNIEnv();
if (m_embeddedView) {
env->DeleteGlobalRef(m_embeddedView);
}
SkSafeUnref(m_flipPixelRef);
SkSafeUnref(m_layer);
}
void PluginWidgetAndroid::init(android::WebViewCore* core) {
m_core = core;
m_core->addPlugin(this);
m_acceptEvents = true;
PLUGIN_LOG("%p Initialized Plugin", m_pluginView->instance());
}
static SkBitmap::Config computeConfig(bool isTransparent) {
return isTransparent ? SkBitmap::kARGB_8888_Config
: SkBitmap::kRGB_565_Config;
}
void PluginWidgetAndroid::setWindow(NPWindow* window, bool isTransparent) {
// store the reference locally for easy lookup
m_pluginWindow = window;
// make a copy of the previous bounds
SkIRect oldPluginBounds = m_pluginBounds;
// keep a local copy of the plugin bounds because the m_pluginWindow pointer
// gets updated values prior to this method being called
m_pluginBounds.set(m_pluginWindow->x, m_pluginWindow->y,
m_pluginWindow->x + m_pluginWindow->width,
m_pluginWindow->y + m_pluginWindow->height);
PLUGIN_LOG("%p PluginBounds (%d,%d,%d,%d)", m_pluginView->instance(),
m_pluginBounds.fLeft, m_pluginBounds.fTop,
m_pluginBounds.fRight, m_pluginBounds.fBottom);
const bool boundsChanged = m_pluginBounds != oldPluginBounds;
//TODO hack to ensure that we grab the most recent screen dimensions and scale
ANPRectI screenCoords;
m_core->getVisibleScreen(screenCoords);
float scale = m_core->scale();
bool scaleChanged = m_cachedZoomLevel != scale;
setVisibleScreen(screenCoords, scale);
// if the scale changed then setVisibleScreen will call this function and
// this call will potentially fire a duplicate draw event
if (!scaleChanged) {
sendSizeAndVisibilityEvents(boundsChanged);
}
layoutSurface(boundsChanged);
if (m_drawingModel != kSurface_ANPDrawingModel) {
SkSafeUnref(m_flipPixelRef);
m_flipPixelRef = new SkFlipPixelRef(computeConfig(isTransparent),
window->width, window->height);
}
}
bool PluginWidgetAndroid::setDrawingModel(ANPDrawingModel model) {
if (model == kOpenGL_ANPDrawingModel && m_layer == 0) {
jobject webview = m_core->getWebViewJavaObject();
AutoJObject webViewCore = m_core->getJavaObject();
m_layer = new WebCore::MediaLayer(webview, webViewCore.get());
}
else if (model != kOpenGL_ANPDrawingModel && m_layer != 0) {
m_layer->unref();
m_layer = 0;
}
if (m_drawingModel != model) {
// Trigger layer computation in RenderLayerCompositor
m_pluginView->getElement()->setNeedsStyleRecalc(SyntheticStyleChange);
}
m_drawingModel = model;
return true;
}
void PluginWidgetAndroid::checkSurfaceReady() {
if(!m_drawEventDelayed)
return;
m_drawEventDelayed = false;
sendSizeAndVisibilityEvents(true);
}
// returned rect is in the page coordinate
bool PluginWidgetAndroid::isDirty(SkIRect* rect) const {
// nothing to report if we haven't had setWindow() called yet
if (NULL == m_flipPixelRef) {
return false;
}
const SkRegion& dirty = m_flipPixelRef->dirtyRgn();
if (dirty.isEmpty()) {
return false;
} else {
if (rect) {
*rect = dirty.getBounds();
rect->offset(m_pluginWindow->x, m_pluginWindow->y);
}
return true;
}
}
void PluginWidgetAndroid::inval(const WebCore::IntRect& rect,
bool signalRedraw) {
// nothing to do if we haven't had setWindow() called yet. m_flipPixelRef
// will also be null if this is a Surface model.
if (NULL == m_flipPixelRef) {
return;
}
m_flipPixelRef->inval(rect);
if (signalRedraw && m_flipPixelRef->isDirty()) {
m_core->invalPlugin(this);
}
}
void PluginWidgetAndroid::viewInvalidate() {
WebCore::IntRect rect(m_pluginBounds.fLeft, m_pluginBounds.fTop,
m_pluginBounds.width(), m_pluginBounds.height());
m_core->viewInvalidate(rect);
}
void PluginWidgetAndroid::draw(PlatformGraphicsContext* context) {
if (NULL == m_flipPixelRef || !m_flipPixelRef->isDirty()) {
return;
}
SkAutoFlipUpdate update(m_flipPixelRef);
const SkBitmap& bitmap = update.bitmap();
const SkRegion& dirty = update.dirty();
ANPEvent event;
SkANP::InitEvent(&event, kDraw_ANPEventType);
event.data.draw.model = m_drawingModel;
SkANP::SetRect(&event.data.draw.clip, dirty.getBounds());
switch (m_drawingModel) {
case kBitmap_ANPDrawingModel: {
WebCore::PluginPackage* pkg = m_pluginView->plugin();
NPP instance = m_pluginView->instance();
if (SkANP::SetBitmap(&event.data.draw.data.bitmap,
bitmap) &&
pkg->pluginFuncs()->event(instance, &event)) {
if (context && m_pluginWindow) {
SkBitmap bm(bitmap);
bm.setPixelRef(m_flipPixelRef);
IntRect dst(0, 0, bm.width(), bm.height());
context->drawBitmapRect(bm, 0, dst);
}
}
break;
}
default:
break;
}
}
void PluginWidgetAndroid::setSurfaceClip(const SkIRect& clip) {
if (m_drawingModel != kSurface_ANPDrawingModel)
return;
/* don't display surfaces that are either entirely clipped or only 1x1 in
size. It appears that when an element is absolutely positioned and has
been completely clipped in CSS that webkit still sends a clip of 1x1.
*/
bool clippedOut = (clip.width() <= 1 && clip.height() <= 1);
if(clippedOut != m_isSurfaceClippedOut) {
m_isSurfaceClippedOut = clippedOut;
layoutSurface();
}
}
void PluginWidgetAndroid::layoutSurface(bool pluginBoundsChanged) {
if (m_drawingModel != kSurface_ANPDrawingModel)
return;
if (!m_pluginWindow)
return;
bool displayPlugin = m_pluginView->isVisible() && !m_isSurfaceClippedOut;
PLUGIN_LOG("%p DisplayPlugin[%d] visible=[%d] clipped=[%d]",
m_pluginView->instance(), displayPlugin,
m_pluginView->isVisible(), m_isSurfaceClippedOut);
// if the surface does not exist then create a new surface
if (!m_embeddedView && displayPlugin) {
WebCore::PluginPackage* pkg = m_pluginView->plugin();
NPP instance = m_pluginView->instance();
jobject pluginSurface;
pkg->pluginFuncs()->getvalue(instance, kJavaSurface_ANPGetValue,
static_cast<void*>(&pluginSurface));
jobject tempObj = m_core->addSurface(pluginSurface,
m_pluginWindow->x, m_pluginWindow->y,
m_pluginWindow->width, m_pluginWindow->height);
if (tempObj) {
JNIEnv* env = JSC::Bindings::getJNIEnv();
m_embeddedView = env->NewGlobalRef(tempObj);
m_embeddedViewAttached = true;
}
// if the view is unattached but visible then attach it
} else if (m_embeddedView && !m_embeddedViewAttached && displayPlugin && !m_isFullScreen) {
m_core->updateSurface(m_embeddedView, m_pluginWindow->x, m_pluginWindow->y,
m_pluginWindow->width, m_pluginWindow->height);
m_embeddedViewAttached = true;
// if the view is attached but invisible then remove it
} else if (m_embeddedView && m_embeddedViewAttached && !displayPlugin) {
m_core->destroySurface(m_embeddedView);
m_embeddedViewAttached = false;
// if the plugin's bounds have changed and it's visible then update it
} else if (pluginBoundsChanged && displayPlugin && !m_isFullScreen) {
m_core->updateSurface(m_embeddedView, m_pluginWindow->x, m_pluginWindow->y,
m_pluginWindow->width, m_pluginWindow->height);
}
}
int16_t PluginWidgetAndroid::sendEvent(const ANPEvent& evt) {
if (!m_acceptEvents)
return 0;
WebCore::PluginPackage* pkg = m_pluginView->plugin();
NPP instance = m_pluginView->instance();
// "missing" plugins won't have these
if (pkg && instance) {
// if the plugin is gaining focus then update our state now to allow
// the plugin's event handler to perform actions that require focus
if (evt.eventType == kLifecycle_ANPEventType &&
evt.data.lifecycle.action == kGainFocus_ANPLifecycleAction) {
m_hasFocus = true;
}
#if DEBUG_EVENTS
SkMSec startTime = SkTime::GetMSecs();
#endif
// make a localCopy since the actual plugin may not respect its constness,
// and so we don't want our caller to have its param modified
ANPEvent localCopy = evt;
int16_t result = pkg->pluginFuncs()->event(instance, &localCopy);
#if DEBUG_EVENTS
SkMSec endTime = SkTime::GetMSecs();
PLUGIN_LOG_EVENT(instance, &evt, result, endTime - startTime);
#endif
// if the plugin is losing focus then delay the update of our state
// until after we notify the plugin and allow them to perform actions
// that may require focus
if (evt.eventType == kLifecycle_ANPEventType &&
evt.data.lifecycle.action == kLoseFocus_ANPLifecycleAction) {
m_hasFocus = false;
}
return result;
}
return 0;
}
void PluginWidgetAndroid::updateEventFlags(ANPEventFlags flags) {
// if there are no differences then immediately return
if (m_eventFlags == flags) {
return;
}
Document* doc = m_pluginView->parentFrame()->document();
#if ENABLE(TOUCH_EVENTS)
if((m_eventFlags ^ flags) & kTouch_ANPEventFlag) {
if (flags & kTouch_ANPEventFlag)
doc->addListenerTypeIfNeeded(eventNames().touchstartEvent);
}
#endif
m_eventFlags = flags;
}
bool PluginWidgetAndroid::isAcceptingEvent(ANPEventFlag flag) {
return m_eventFlags & flag;
}
void PluginWidgetAndroid::sendSizeAndVisibilityEvents(const bool updateDimensions) {
if (m_drawingModel == kOpenGL_ANPDrawingModel &&
!m_layer->acquireNativeWindowForContent()) {
m_drawEventDelayed = true;
return;
}
// TODO update the bitmap size based on the zoom? (for kBitmap_ANPDrawingModel)
const float zoomLevel = m_core->scale();
// notify the plugin of the new size
if (m_drawingModel == kOpenGL_ANPDrawingModel && updateDimensions && m_pluginWindow) {
PLUGIN_LOG("%s (%d,%d)[%f]", __FUNCTION__, m_pluginWindow->width,
m_pluginWindow->height, zoomLevel);
ANPEvent event;
SkANP::InitEvent(&event, kDraw_ANPEventType);
event.data.draw.model = kOpenGL_ANPDrawingModel;
event.data.draw.data.surface.width = m_pluginWindow->width * zoomLevel;
event.data.draw.data.surface.height = m_pluginWindow->height * zoomLevel;
sendEvent(event);
}
bool visible = SkIRect::Intersects(m_visibleDocRect, m_pluginBounds);
if(m_visible != visible) {
#if DEBUG_VISIBLE_RECTS
PLUGIN_LOG("%p changeVisiblity[%d] pluginBounds(%d,%d,%d,%d)",
m_pluginView->instance(), visible,
m_pluginBounds.fLeft, m_pluginBounds.fTop,
m_pluginBounds.fRight, m_pluginBounds.fBottom);
#endif
// change the visibility
m_visible = visible;
// send the event
ANPEvent event;
SkANP::InitEvent(&event, kLifecycle_ANPEventType);
event.data.lifecycle.action = visible ? kOnScreen_ANPLifecycleAction
: kOffScreen_ANPLifecycleAction;
sendEvent(event);
}
}
void PluginWidgetAndroid::setVisibleScreen(const ANPRectI& visibleDocRect, float zoom) {
#if DEBUG_VISIBLE_RECTS
PLUGIN_LOG("%s (%d,%d,%d,%d)[%f]", __FUNCTION__, visibleDocRect.left,
visibleDocRect.top, visibleDocRect.right,
visibleDocRect.bottom, zoom);
#endif
int oldScreenW = m_visibleDocRect.width();
int oldScreenH = m_visibleDocRect.height();
const bool zoomChanged = m_cachedZoomLevel != zoom;
// make local copies of the parameters
m_cachedZoomLevel = zoom;
m_visibleDocRect.set(visibleDocRect.left,
visibleDocRect.top,
visibleDocRect.right,
visibleDocRect.bottom);
int newScreenW = m_visibleDocRect.width();
int newScreenH = m_visibleDocRect.height();
// if the screen dimensions have changed by more than 5 pixels in either
// direction then recompute the plugin's visible rectangle
if (abs(oldScreenW - newScreenW) > 5 || abs(oldScreenH - newScreenH) > 5) {
PLUGIN_LOG("%s VisibleDoc old=[%d,%d] new=[%d,%d] ", __FUNCTION__,
oldScreenW, oldScreenH, newScreenW, newScreenH);
computeVisiblePluginRect();
}
sendSizeAndVisibilityEvents(zoomChanged);
}
ANPRectI PluginWidgetAndroid::visibleRect() {
SkIRect visibleRect;
visibleRect.setEmpty();
// compute the interesection of the visible screen and the plugin
bool visible = visibleRect.intersect(m_visibleDocRect, m_pluginBounds);
if (visible) {
// convert from absolute coordinates to the plugin's relative coordinates
visibleRect.offset(-m_pluginBounds.fLeft, -m_pluginBounds.fTop);
}
// convert from SkRect to ANPRect
ANPRectI result;
memcpy(&result, &visibleRect, sizeof(ANPRectI));
return result;
}
void PluginWidgetAndroid::setVisibleRects(const ANPRectI rects[], int32_t count) {
#if DEBUG_VISIBLE_RECTS
PLUGIN_LOG("%s count=%d", __FUNCTION__, count);
#endif
// ensure the count does not exceed our allocated space
if (count > MAX_REQUESTED_RECTS)
count = MAX_REQUESTED_RECTS;
// store the values in member variables
m_requestedVisibleRectCount = count;
memcpy(m_requestedVisibleRects, rects, count * sizeof(rects[0]));
#if DEBUG_VISIBLE_RECTS // FIXME: this fixes bad data from the plugin
// take it out once plugin supplies better data
for (int index = 0; index < count; index++) {
PLUGIN_LOG("%s [%d](%d,%d,%d,%d)", __FUNCTION__, index,
m_requestedVisibleRects[index].left,
m_requestedVisibleRects[index].top,
m_requestedVisibleRects[index].right,
m_requestedVisibleRects[index].bottom);
if (m_requestedVisibleRects[index].left ==
m_requestedVisibleRects[index].right) {
m_requestedVisibleRects[index].right += 1;
}
if (m_requestedVisibleRects[index].top ==
m_requestedVisibleRects[index].bottom) {
m_requestedVisibleRects[index].bottom += 1;
}
}
#endif
computeVisiblePluginRect();
}
void PluginWidgetAndroid::computeVisiblePluginRect() {
// ensure the visibleDocRect has been set (i.e. not equal to zero)
if (m_visibleDocRect.isEmpty() || !m_pluginWindow || m_requestedVisibleRectCount < 1)
return;
// create a rect that will contain as many of the rects that will fit on screen
SkIRect visibleRect;
visibleRect.setEmpty();
for (int counter = 0; counter < m_requestedVisibleRectCount; counter++) {
ANPRectI* rect = &m_requestedVisibleRects[counter];
// create skia rect for easier manipulation and convert it to page coordinates
SkIRect pluginRect;
pluginRect.set(rect->left, rect->top, rect->right, rect->bottom);
pluginRect.offset(m_pluginWindow->x, m_pluginWindow->y);
// ensure the rect falls within the plugin's bounds
if (!m_pluginBounds.contains(pluginRect)) {
#if DEBUG_VISIBLE_RECTS
PLUGIN_LOG("%s (%d,%d,%d,%d) !contain (%d,%d,%d,%d)", __FUNCTION__,
m_pluginBounds.fLeft, m_pluginBounds.fTop,
m_pluginBounds.fRight, m_pluginBounds.fBottom,
pluginRect.fLeft, pluginRect.fTop,
pluginRect.fRight, pluginRect.fBottom);
// assume that the desired outcome is to clamp to the container
if (pluginRect.intersect(m_pluginBounds)) {
visibleRect = pluginRect;
}
#endif
continue;
}
// combine this new rect with the higher priority rects
pluginRect.join(visibleRect);
// check to see if the new rect could be made to fit within the screen
// bounds. If this is the highest priority rect then attempt to center
// even if it doesn't fit on the screen.
if (counter > 0 && (m_visibleDocRect.width() < pluginRect.width() ||
m_visibleDocRect.height() < pluginRect.height()))
break;
// set the new visible rect
visibleRect = pluginRect;
}
m_requestedVisibleRect = visibleRect;
scrollToVisiblePluginRect();
}
void PluginWidgetAndroid::scrollToVisiblePluginRect() {
if (!m_hasFocus || m_requestedVisibleRect.isEmpty() || m_visibleDocRect.isEmpty()) {
#if DEBUG_VISIBLE_RECTS
PLUGIN_LOG("%s call m_hasFocus=%d m_requestedVisibleRect.isEmpty()=%d"
" m_visibleDocRect.isEmpty()=%d", __FUNCTION__, m_hasFocus,
m_requestedVisibleRect.isEmpty(), m_visibleDocRect.isEmpty());
#endif
return;
}
// if the entire rect is already visible then we don't need to scroll
if (m_visibleDocRect.contains(m_requestedVisibleRect))
return;
// find the center of the visibleRect in document coordinates
int rectCenterX = m_requestedVisibleRect.fLeft + m_requestedVisibleRect.width()/2;
int rectCenterY = m_requestedVisibleRect.fTop + m_requestedVisibleRect.height()/2;
// position the corner of the visible doc to center the requested rect
int scrollDocX = MAX(0, rectCenterX - (m_visibleDocRect.width()/2));
int scrollDocY = MAX(0, rectCenterY - (m_visibleDocRect.height()/2));
ScrollView* scrollView = m_pluginView->parent();
android::WebViewCore* core = android::WebViewCore::getWebViewCore(scrollView);
#if DEBUG_VISIBLE_RECTS
PLUGIN_LOG("%s call scrollTo (%d,%d) to center (%d,%d)", __FUNCTION__,
scrollDocX, scrollDocY, rectCenterX, rectCenterY);
#endif
core->scrollTo(scrollDocX, scrollDocY, true);
}
void PluginWidgetAndroid::requestFullScreen() {
if (m_isFullScreen) {
return;
}
if (!m_embeddedView && m_drawingModel == kOpenGL_ANPDrawingModel) {
WebCore::PluginPackage* pkg = m_pluginView->plugin();
NPP instance = m_pluginView->instance();
jobject pluginSurface;
pkg->pluginFuncs()->getvalue(instance, kJavaSurface_ANPGetValue,
static_cast<void*>(&pluginSurface));
// create the surface, but do not add it to the view hierarchy
jobject tempObj = m_core->createSurface(pluginSurface);
if (tempObj) {
JNIEnv* env = JSC::Bindings::getJNIEnv();
m_embeddedView = env->NewGlobalRef(tempObj);
m_embeddedViewAttached = false;
}
}
if (!m_embeddedView) {
return;
}
// send event to notify plugin of full screen change
ANPEvent event;
SkANP::InitEvent(&event, kLifecycle_ANPEventType);
event.data.lifecycle.action = kEnterFullScreen_ANPLifecycleAction;
sendEvent(event);
// remove the embedded surface from the view hierarchy
if (m_drawingModel != kOpenGL_ANPDrawingModel)
m_core->destroySurface(m_embeddedView);
// add the full screen view
m_core->showFullScreenPlugin(m_embeddedView, m_fullScreenOrientation,
m_pluginView->instance());
m_isFullScreen = true;
}
void PluginWidgetAndroid::exitFullScreen(bool pluginInitiated) {
if (!m_isFullScreen || !m_embeddedView) {
return;
}
// remove the full screen surface from the view hierarchy
if (pluginInitiated) {
m_core->hideFullScreenPlugin();
}
// add the embedded view back
if (m_drawingModel != kOpenGL_ANPDrawingModel)
m_core->updateSurface(m_embeddedView, m_pluginWindow->x, m_pluginWindow->y,
m_pluginWindow->width, m_pluginWindow->height);
// send event to notify plugin of full screen change
ANPEvent event;
SkANP::InitEvent(&event, kLifecycle_ANPEventType);
event.data.lifecycle.action = kExitFullScreen_ANPLifecycleAction;
sendEvent(event);
m_isFullScreen = false;
}
void PluginWidgetAndroid::setFullScreenOrientation(ANPScreenOrientation orientation) {
int internalOrienationId;
/* We need to validate that the input is legitimate and then convert the
* value from the plugin enum to the enum used by the android view system.
* The view system values correspond to those values for the
* screenOrientation attribute in R.java (see also ActivityInfo.java).
*/
switch (orientation) {
case kFixedLandscape_ANPScreenOrientation:
internalOrienationId = 0;
break;
case kFixedPortrait_ANPScreenOrientation:
internalOrienationId = 1;
break;
case kLandscape_ANPScreenOrientation:
internalOrienationId = 6;
break;
case kPortrait_ANPScreenOrientation:
internalOrienationId = 7;
break;
default:
internalOrienationId = -1;
}
PLUGIN_LOG("%s orientation (%d)", __FUNCTION__, internalOrienationId);
m_fullScreenOrientation = internalOrienationId;
}
void PluginWidgetAndroid::requestCenterFitZoom() {
m_core->centerFitRect(m_pluginWindow->x, m_pluginWindow->y,
m_pluginWindow->width, m_pluginWindow->height);
}
void PluginWidgetAndroid::setPowerState(ANPPowerState powerState) {
if(m_powerState == powerState)
return;
// cleanup the old power state
switch (m_powerState) {
case kDefault_ANPPowerState:
break;
case kScreenOn_ANPPowerState:
m_core->keepScreenOn(false);
break;
}
// setup the new power state
switch (powerState) {
case kDefault_ANPPowerState:
break;
case kScreenOn_ANPPowerState:
m_core->keepScreenOn(true);
break;
}
m_powerState = powerState;
}