自学教程：C++ ANPLogInterfaceV0类代码示例

int16_t VideoPlugin::handleEvent(const ANPEvent* evt) {    switch (evt->eventType) {        case kLifecycle_ANPEventType: {            switch (evt->data.lifecycle.action) {                case kEnterFullScreen_ANPLifecycleAction:                    gLogI.log(kDebug_ANPLogType, " ---- %p entering fullscreen", inst());                    break;                case kExitFullScreen_ANPLifecycleAction:                    gLogI.log(kDebug_ANPLogType, " ---- %p exiting fullscreen", inst());                    break;            }            break; // end kLifecycle_ANPEventType        }        case kDraw_ANPEventType:            gLogI.log(kError_ANPLogType, " ------ %p the plugin did not request draw events", inst());            break;        case kTouch_ANPEventType:            if (kDown_ANPTouchAction == evt->data.touch.action) {                gLogI.log(kDebug_ANPLogType, " ------ %p requesting fullscreen mode", inst());                gWindowI.requestFullScreen(inst());            }            return 1;        case kKey_ANPEventType:            gLogI.log(kError_ANPLogType, " ------ %p the plugin did not request key events", inst());            break;        default:            break;    }    return 0;   // unknown or unhandled event}

void BackgroundPlugin::test_loadJavaClass() {    JNIEnv* env = NULL;    if (gVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {        gLogI.log(kError_ANPLogType, " ---- LoadJavaTest: failed to get env");        return;    }    const char* className = "com.android.sampleplugin.BackgroundTest";    jclass backgroundClass = gSystemI.loadJavaClass(inst(), className);    if(!backgroundClass) {        gLogI.log(kError_ANPLogType, " ---- LoadJavaTest: failed to load class");        return;    }    jmethodID constructor = env->GetMethodID(backgroundClass, "<init>", "()V");    jmethodID addMethod = env->GetMethodID(backgroundClass, "addInt", "(II)I");    jobject backgroundObject = env->NewObject(backgroundClass, constructor);    if(!backgroundObject) {        gLogI.log(kError_ANPLogType, " ---- LoadJavaTest: failed to construct object");        return;    }    jint result = env->CallIntMethod(backgroundObject, addMethod, 2, 2);    if (result != 4) {        gLogI.log(kError_ANPLogType, " ---- LoadJavaTest: invalid result (%d != 4)", result);    }}

static void test_formats(NPP instance) {    // TODO pull names from enum in npapi instead of hardcoding them    static const struct {        ANPBitmapFormat fFormat;        const char*     fName;    } gRecs[] = {        { kUnknown_ANPBitmapFormat,   "unknown" },        { kRGBA_8888_ANPBitmapFormat, "8888" },        { kRGB_565_ANPBitmapFormat,   "565" },    };    ANPPixelPacking packing;    for (size_t i = 0; i < ARRAY_COUNT(gRecs); i++) {        if (gBitmapI.getPixelPacking(gRecs[i].fFormat, &packing)) {            gLogI.log(kDebug_ANPLogType,                      "pixel format [%d] %s has packing ARGB [%d %d] [%d %d] [%d %d] [%d %d]/n",                      gRecs[i].fFormat, gRecs[i].fName,                      packing.AShift, packing.ABits,                      packing.RShift, packing.RBits,                      packing.GShift, packing.GBits,                      packing.BShift, packing.BBits);        } else {            gLogI.log(kDebug_ANPLogType,                      "pixel format [%d] %s has no packing/n",                      gRecs[i].fFormat, gRecs[i].fName);        }    }}

int16_t BackgroundPlugin::handleEvent(const ANPEvent* evt) {    switch (evt->eventType) {        case kDraw_ANPEventType:            gLogI.log(kError_ANPLogType, " ------ %p the plugin did not request draw events", inst());            break;        case kLifecycle_ANPEventType:            switch (evt->data.lifecycle.action)  {                case kOnLoad_ANPLifecycleAction:                    gLogI.log(kDebug_ANPLogType, " ------ %p onLoad", inst());                    return 1;                case kOnScreen_ANPLifecycleAction:                    gLogI.log(kDebug_ANPLogType, " ------ %p onScreen", inst());                    return 1;                case kOffScreen_ANPLifecycleAction:                    gLogI.log(kDebug_ANPLogType, " ------ %p offScreen", inst());                    return 1;            }            break; // end kLifecycle_ANPEventType        case kTouch_ANPEventType:            if (kLongPress_ANPTouchAction == evt->data.touch.action) {                browser->geturl(inst(), "javascript:alert('Detected long press event.')", 0);                gWindowI.requestFullScreen(inst());            }            else if (kDoubleTap_ANPTouchAction == evt->data.touch.action)                browser->geturl(inst(), "javascript:alert('Detected double tap event.')", 0);            break;        case kKey_ANPEventType:            gLogI.log(kError_ANPLogType, " ------ %p the plugin did not request key events", inst());            break;        default:            break;    }    return 0;   // unknown or unhandled event}

jobject BackgroundPlugin::getSurface() {    if (m_surface) {        return m_surface;    }    // load the appropriate java class and instantiate it    JNIEnv* env = NULL;    if (gVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {        gLogI.log(kError_ANPLogType, " ---- getSurface: failed to get env");        return NULL;    }    const char* className = "com.android.sampleplugin.BackgroundSurface";    jclass backgroundClass = gSystemI.loadJavaClass(inst(), className);    if(!backgroundClass) {        gLogI.log(kError_ANPLogType, " ---- getSurface: failed to load class");        return NULL;    }    jmethodID constructor = env->GetMethodID(backgroundClass, "<init>", "(Landroid/content/Context;)V");    jobject backgroundSurface = env->NewObject(backgroundClass, constructor, m_context);    if(!backgroundSurface) {        gLogI.log(kError_ANPLogType, " ---- getSurface: failed to construct object");        return NULL;    }    m_surface = env->NewGlobalRef(backgroundSurface);    return m_surface;}

jobject PaintPlugin::getSurface() {    if (m_surface) {        return m_surface;    }    // load the appropriate java class and instantiate it    JNIEnv* env = NULL;    if (gVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {        gLogI.log(kError_ANPLogType, " ---- getSurface: failed to get env");        return NULL;    }    const char* className = "com.android.sampleplugin.PaintSurface";    jclass paintClass = gSystemI.loadJavaClass(inst(), className);    if(!paintClass) {        gLogI.log(kError_ANPLogType, " ---- getSurface: failed to load class");        return NULL;    }    PluginObject *obj = (PluginObject*) inst()->pdata;    const int pW = obj->window->width;    const int pH = obj->window->height;    jmethodID constructor = env->GetMethodID(paintClass, "<init>", "(Landroid/content/Context;III)V");    jobject paintSurface = env->NewObject(paintClass, constructor, m_context, (int)inst(), pW, pH);    if(!paintSurface) {        gLogI.log(kError_ANPLogType, " ---- getSurface: failed to construct object");        return NULL;    }    m_surface = env->NewGlobalRef(paintSurface);    return m_surface;}

void BackgroundPlugin::test_javascript() {    NPP instance = this->inst();    gLogI.log(kDebug_ANPLogType, " ------ %p Testing JavaScript Access", instance);    // Get the plugin's DOM object    NPObject* windowObject = NULL;    browser->getvalue(instance, NPNVWindowNPObject, &windowObject);    if (!windowObject)        gLogI.log(kError_ANPLogType, " ------ %p Unable to retrieve DOM Window", instance);    // create a string (JS code) that is stored in memory allocated by the browser    const char* jsString = "1200 + 34";    void* stringMem = browser->memalloc(strlen(jsString));    memcpy(stringMem, jsString, strlen(jsString));    // execute the javascript in the plugin's DOM object    NPString script = { (char*)stringMem, strlen(jsString) };    NPVariant scriptVariant;    if (!browser->evaluate(instance, windowObject, &script, &scriptVariant))        gLogI.log(kError_ANPLogType, " ------ %p Unable to eval the JS.", instance);    if (scriptVariant.type == NPVariantType_Int32) {        if (scriptVariant.value.intValue != 1234)            gLogI.log(kError_ANPLogType, " ------ %p Invalid Value for JS Return: %d,1234", instance, scriptVariant.value.intValue);    } else {        gLogI.log(kError_ANPLogType, " ------ %p Invalid Variant type for JS Return: %d,%d", instance, scriptVariant.type, NPVariantType_Int32);    }    // free the memory allocated within the browser    browser->memfree(stringMem);}

void BackgroundPlugin::test_logging() {    NPP instance = this->inst();    //LOG_ERROR(instance, " ------ %p Testing Log Error", instance);    gLogI.log(kError_ANPLogType, " ------ %p Testing Log Error", instance);    gLogI.log(kWarning_ANPLogType, " ------ %p Testing Log Warning", instance);    gLogI.log(kDebug_ANPLogType, " ------ %p Testing Log Debug", instance);}

static void surfaceDestroyed(JNIEnv* jniEnv, jobject thiz, jint npp){  // give up all handles to the VM and any VM objects!  NPP instance = (NPP)npp;  if(!instance)    return;  gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceDestroyed() instance=%p ...",instance);/*  SurfaceSubPlugin* obj = getPluginObject(npp);  if(obj)    obj->surfaceDestroyed();    // call PaintPlugin.cpp surfaceDestroyed()*/  if(instance->pdata!=NULL)  {    PluginObject* plugin = static_cast<PluginObject*>(instance->pdata);    gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceDestroyed() plugin=%p",plugin);/*    if(plugin)    {      if((int)plugin<0x10000)      {        gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceDestroyed() plugin<0x10000 ############################################");        return;      }      gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceDestroyed() plugin->dexLoaderClass=%p",plugin->dexLoaderClass);      // call applet stop() via DexLoader.callstop()      if(plugin->dexLoaderClass && !needDexInit)      {        const char* stopMethodName = "callStop";        gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceDestroyed() GetStaticMethodID(%s)...",stopMethodName);        jmethodID  stopMethod = jniEnv->GetStaticMethodID(plugin->dexLoaderClass, stopMethodName, "()V");        if(stopMethod == NULL)        {          gLogI.log(instance, kError_ANPLogType, "jni-bridge surfaceCreated() JavaVM unable to find %s() via dexLoaderClass ################################################", stopMethodName);        }        else        {          jniEnv->CallStaticVoidMethod(plugin->dexLoaderClass, stopMethod, NULL);        }      }    }*/  }  needDexInit=true;  gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceDestroyed done");}

void BackgroundPlugin::drawPlugin(int surfaceWidth, int surfaceHeight) {    // get the plugin's dimensions according to the DOM    PluginObject *obj = (PluginObject*) inst()->pdata;    const int W = obj->window->width;    const int H = obj->window->height;    // compute the current zoom level    const float zoomFactorW = static_cast<float>(surfaceWidth) / W;    const float zoomFactorH = static_cast<float>(surfaceHeight) / H;    // check to make sure the zoom level is uniform    if (zoomFactorW + .01 < zoomFactorH && zoomFactorW - .01 > zoomFactorH)        gLogI.log(kError_ANPLogType, " ------ %p zoom is out of sync (%f,%f)",                  inst(), zoomFactorW, zoomFactorH);    // scale the variables based on the zoom level    const int fontSize = (int)(zoomFactorW * 16);    const int leftMargin = (int)(zoomFactorW * 10);    // lock the surface    ANPBitmap bitmap;    JNIEnv* env = NULL;    if (!m_surface || gVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK ||        !gSurfaceI.lock(env, m_surface, &bitmap, NULL)) {        gLogI.log(kError_ANPLogType, " ------ %p unable to lock the plugin", inst());        return;    }    // create a canvas    ANPCanvas* canvas = gCanvasI.newCanvas(&bitmap);    gCanvasI.drawColor(canvas, 0xFFFFFFFF);    ANPPaint* paint = gPaintI.newPaint();    gPaintI.setFlags(paint, gPaintI.getFlags(paint) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(paint, 0xFFFF0000);    gPaintI.setTextSize(paint, fontSize);    ANPTypeface* tf = gTypefaceI.createFromName("serif", kItalic_ANPTypefaceStyle);    gPaintI.setTypeface(paint, tf);    gTypefaceI.unref(tf);    ANPFontMetrics fm;    gPaintI.getFontMetrics(paint, &fm);    gPaintI.setColor(paint, 0xFF0000FF);    const char c[] = "This is a background plugin.";    gCanvasI.drawText(canvas, c, sizeof(c)-1, leftMargin, -fm.fTop, paint);    // clean up variables and unlock the surface    gPaintI.deletePaint(paint);    gCanvasI.deleteCanvas(canvas);    gSurfaceI.unlock(env, m_surface);}

void AudioPlugin::handleTouch(int x, int y) {    NPP instance = this->inst();    // if the track is null then return    if (NULL == m_soundPlay->track) {        gLogI.log(kError_ANPLogType, "---- %p unable to create track",                  instance);        return;    }    // check to make sure the currentRect matches the activeRect    ANPRectF* currentRect = validTouch(x,y);    if (m_activeTouchRect != currentRect)        return;    if (currentRect == &m_playRect) {        gLogI.log(kDebug_ANPLogType, "---- %p starting track (%d)",                  m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));        if (gSoundI.isStopped(m_soundPlay->track)) {            gSoundI.start(m_soundPlay->track);        }    }    else if (currentRect == &m_pauseRect) {        gLogI.log(kDebug_ANPLogType, "---- %p pausing track (%d)",                  m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));        if (!gSoundI.isStopped(m_soundPlay->track)) {            gSoundI.pause(m_soundPlay->track);        }    }    else if (currentRect == &m_stopRect) {        gLogI.log(kDebug_ANPLogType, "---- %p stopping track (%d)",                  m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));        if (!gSoundI.isStopped(m_soundPlay->track)) {            gSoundI.stop(m_soundPlay->track);        }        if (m_soundPlay->file) {            fseek(m_soundPlay->file, 0, SEEK_SET);        }    }    else {        gLogI.log(kDebug_ANPLogType, "---- touch x:%d, y:%d ", x, y);        return;    }    // set the currentRect to be the activeRect    m_activeRect = currentRect;    inval(instance);}

bool NavigationPlugin::handleNavigation(ANPKeyCode keyCode) {    NPP instance = this->inst();    gLogI.log(kDebug_ANPLogType, "----%p Received Key %d", instance, keyCode);    switch (keyCode) {		case kDpadUp_ANPKeyCode:			m_activeNav = &m_navUp;			break;		case kDpadDown_ANPKeyCode:			m_activeNav = &m_navDown;			break;		case kDpadLeft_ANPKeyCode:			m_activeNav = &m_navLeft;			break;		case kDpadRight_ANPKeyCode:			m_activeNav = &m_navRight;			break;		case kDpadCenter_ANPKeyCode:			m_activeNav = &m_navCenter;			break;		case kQ_ANPKeyCode:		case kDel_ANPKeyCode:			m_activeNav = NULL;			return false;		default:			m_activeNav = NULL;			break;    }    return true;}

BackgroundPlugin::BackgroundPlugin(NPP inst) : SurfaceSubPlugin(inst) {    // initialize the drawing surface    m_surface = NULL;    //initialize bitmap transparency variables    mFinishedStageOne   = false;    mFinishedStageTwo   = false;    mFinishedStageThree = false;    // test basic plugin functionality    test_logging(); // android logging    test_timers();  // plugin timers    test_bitmaps(); // android bitmaps    test_domAccess();    test_javascript();    test_loadJavaClass();    //register for touch events    ANPEventFlags flags = kTouch_ANPEventFlag;    NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);    if (err != NPERR_NO_ERROR) {        gLogI.log(kError_ANPLogType, "Error selecting input events.");    }}

NPError NPP_GetValue(NPP instance, NPPVariable variable, void* value){    if (variable == NPPVpluginScriptableNPObject) {        void **v = (void **)value;        PluginObject *obj = (PluginObject*) instance->pdata;        if (obj)            browser->retainobject(&obj->header);        *v = &(obj->header);        return NPERR_NO_ERROR;    }    if (variable == kJavaSurface_ANPGetValue) {        //get the surface sub-plugin        PluginObject* obj = static_cast<PluginObject*>(instance->pdata);        if (obj && obj->activePlugin) {            if(obj->activePlugin->supportsDrawingModel(kSurface_ANPDrawingModel)                    || obj->activePlugin->supportsDrawingModel(kOpenGL_ANPDrawingModel)) {                SurfaceSubPlugin* plugin = static_cast<SurfaceSubPlugin*>(obj->activePlugin);                jobject* surface = static_cast<jobject*>(value);                *surface = plugin->getSurface();                return NPERR_NO_ERROR;            } else {                gLogI.log(kError_ANPLogType,                          "-- %p Tried to retrieve surface for non-surface plugin",                          instance);            }        }    }    return NPERR_GENERIC_ERROR;}

bool FormPlugin::handleNavigation(ANPKeyCode keyCode) {    NPP instance = this->inst();    gLogI.log(kDebug_ANPLogType, "----%p Recvd Nav Key %d", instance, keyCode);    if (!m_activeInput) {        gWindowI.showKeyboard(instance, true);        switchActiveInput(&m_usernameInput);    }    else if (m_activeInput == &m_usernameInput) {        if (keyCode == kDpadDown_ANPKeyCode) {            switchActiveInput(&m_passwordInput);        }        else if (keyCode == kDpadCenter_ANPKeyCode)            gWindowI.showKeyboard(instance, false);        else if (keyCode == kDpadUp_ANPKeyCode)            return false;    }    else if (m_activeInput == &m_passwordInput) {        if (keyCode == kDpadUp_ANPKeyCode) {            switchActiveInput(&m_usernameInput);        }        else if (keyCode == kDpadCenter_ANPKeyCode)            gWindowI.showKeyboard(instance, false);        else if (keyCode == kDpadDown_ANPKeyCode)            return false;    }    return true;}

int16_t NavigationPlugin::handleEvent(const ANPEvent* evt) {    NPP instance = this->inst();    switch (evt->eventType) {        case kDraw_ANPEventType:            switch (evt->data.draw.model) {                case kBitmap_ANPDrawingModel:                    drawPlugin(evt->data.draw.data.bitmap, evt->data.draw.clip);                    return 1;                default:                    break;   // unknown drawing model            }            break;        case kLifecycle_ANPEventType:            if (evt->data.lifecycle.action == kLoseFocus_ANPLifecycleAction) {                gLogI.log(kDebug_ANPLogType, "----%p Loosing Focus", instance);                m_hasFocus = false;                inval(instance);                return 1;            }            else if (evt->data.lifecycle.action == kGainFocus_ANPLifecycleAction) {                gLogI.log(kDebug_ANPLogType, "----%p Gaining Focus", instance);                m_hasFocus = true;                inval(instance);                return 1;            }            break;        case kMouse_ANPEventType:            return 1;        case kKey_ANPEventType:            if (evt->data.key.action == kDown_ANPKeyAction) {            	bool result = handleNavigation(evt->data.key.nativeCode);            	inval(instance);            	return result;            }            return 1;        default:            break;    }    return 0;   // unknown or unhandled event}

static void timer_repeat(NPP instance, uint32_t timerID) {    BackgroundPlugin *obj = ((BackgroundPlugin*) ((PluginObject*) instance->pdata)->activePlugin);    gLogI.log(kDebug_ANPLogType, "-------- repeat timer %d/n",              obj->mTimerRepeatCount);    if (--obj->mTimerRepeatCount == 0) {        browser->unscheduletimer(instance, timerID);    }}

int16_t AudioPlugin::handleEvent(const ANPEvent* evt) {    //NPP instance = this->inst();    gLogI.log(kError_ANPLogType, "AudioPlugin::handleEvent:%d, action:%d", evt->eventType, evt->data.touch.action);    switch (evt->eventType) {        case kDraw_ANPEventType:            switch (evt->data.draw.model) {                case kBitmap_ANPDrawingModel:                    drawPlugin(evt->data.draw.data.bitmap, evt->data.draw.clip);                    return 1;                default:                    break;   // unknown drawing model            }        case kTouch_ANPEventType:        case kMultiTouch_ANPEventType:            {            int x = evt->data.touch.x;            int y = evt->data.touch.y;            gLogI.log(kError_ANPLogType, "kTouch_ANPEventType:x:%d, y%d", x, y);            if (kDown_ANPTouchAction == evt->data.touch.action) {                m_activeTouchRect = validTouch(x,y);                if(m_activeTouchRect) {                    m_activeTouch = true;                    return 1;                }            } else if (kUp_ANPTouchAction == evt->data.touch.action && m_activeTouch) {                handleTouch(x, y);                m_activeTouch = false;                return 1;            } else if (kCancel_ANPTouchAction == evt->data.touch.action) {                m_activeTouch = false;            }            break;        }        default:            break;    }    return 0;   // unknown or unhandled event}

PaintPlugin::PaintPlugin(NPP inst) : SurfaceSubPlugin(inst) {    m_isTouchActive = false;    m_isTouchCurrentInput = true;    m_activePaintColor = s_redColor;    memset(&m_drawingSurface, 0, sizeof(m_drawingSurface));    memset(&m_inputToggle,  0, sizeof(m_inputToggle));    memset(&m_colorToggle, 0, sizeof(m_colorToggle));    memset(&m_fullScreenToggle, 0, sizeof(m_fullScreenToggle));    memset(&m_clearSurface,  0, sizeof(m_clearSurface));    // initialize the drawing surface    m_surface = NULL;    // initialize the path    m_touchPath = gPathI.newPath();    if(!m_touchPath)        gLogI.log(kError_ANPLogType, "----%p Unable to create the touch path", inst);    // initialize the paint colors    m_paintSurface = gPaintI.newPaint();    gPaintI.setFlags(m_paintSurface, gPaintI.getFlags(m_paintSurface) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintSurface, 0xFFC0C0C0);    gPaintI.setTextSize(m_paintSurface, 18);    m_paintButton = gPaintI.newPaint();    gPaintI.setFlags(m_paintButton, gPaintI.getFlags(m_paintButton) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintButton, 0xFFA8A8A8);    // initialize the typeface (set the colors)    ANPTypeface* tf = gTypefaceI.createFromName("serif", kItalic_ANPTypefaceStyle);    gPaintI.setTypeface(m_paintSurface, tf);    gTypefaceI.unref(tf);    //register for touch events    ANPEventFlags flags = kTouch_ANPEventFlag;    NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);    if (err != NPERR_NO_ERROR) {        gLogI.log(kError_ANPLogType, "Error selecting input events.");    }}

void BackgroundPlugin::test_domAccess() {    NPP instance = this->inst();    gLogI.log(kDebug_ANPLogType, " ------ %p Testing DOM Access", instance);    // Get the plugin's DOM object    NPObject* windowObject = NULL;    browser->getvalue(instance, NPNVWindowNPObject, &windowObject);    if (!windowObject)        gLogI.log(kError_ANPLogType, " ------ %p Unable to retrieve DOM Window", instance);    // Retrieve a property from the plugin's DOM object    NPIdentifier topIdentifier = browser->getstringidentifier("top");    NPVariant topObjectVariant;    browser->getproperty(instance, windowObject, topIdentifier, &topObjectVariant);    if (topObjectVariant.type != NPVariantType_Object)        gLogI.log(kError_ANPLogType, " ------ %p Invalid Variant type for DOM Property: %d,%d", instance, topObjectVariant.type, NPVariantType_Object);}

VideoPlugin::VideoPlugin(NPP inst) : SurfaceSubPlugin(inst) {    // initialize the drawing surface    m_surface = NULL;    //register for touch events    ANPEventFlags flags = kTouch_ANPEventFlag;    NPError err = NPN_SetValue(inst, kAcceptEvents_ANPSetValue, &flags);    if (err != NPERR_NO_ERROR) {        gLogI.log(kError_ANPLogType, "Error selecting input events.");    }}

static void surfaceChanged(JNIEnv* jniEnv, jobject thiz, jint npp, jint format, jint width, jint height){  NPP instance = (NPP)npp;  if(!instance)    return;  gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceChanged()...");  //// NEEDED FOR DRAWING  //SurfaceSubPlugin* obj = getPluginObject(npp);  //if(obj)  //  obj->surfaceChanged(format, width, height);  //gLogI.log(instance, kDebug_ANPLogType, "jni-bridge surfaceChanged() done");}

void BackgroundPlugin::test_bitmap_transparency(const ANPEvent* evt) {    NPP instance = this->inst();    // check default & set transparent    if (!mFinishedStageOne) {        gLogI.log(kDebug_ANPLogType, "BEGIN: testing bitmap transparency");        //check to make sure it is not transparent        if (evt->data.draw.data.bitmap.format == kRGBA_8888_ANPBitmapFormat) {            gLogI.log(kError_ANPLogType, "bitmap default format is transparent");        }        //make it transparent (any non-null value will set it to true)        bool value = true;        NPError err = browser->setvalue(instance, NPPVpluginTransparentBool, &value);        if (err != NPERR_NO_ERROR) {            gLogI.log(kError_ANPLogType, "Error setting transparency.");        }        mFinishedStageOne = true;        browser->invalidaterect(instance, NULL);    }    // check transparent & set opaque    else if (!mFinishedStageTwo) {        //check to make sure it is transparent        if (evt->data.draw.data.bitmap.format != kRGBA_8888_ANPBitmapFormat) {            gLogI.log(kError_ANPLogType, "bitmap did not change to transparent format");        }        //make it opaque        NPError err = browser->setvalue(instance, NPPVpluginTransparentBool, NULL);        if (err != NPERR_NO_ERROR) {            gLogI.log(kError_ANPLogType, "Error setting transparency.");        }        mFinishedStageTwo = true;    }    // check opaque    else if (!mFinishedStageThree) {        //check to make sure it is not transparent        if (evt->data.draw.data.bitmap.format == kRGBA_8888_ANPBitmapFormat) {            gLogI.log(kError_ANPLogType, "bitmap default format is transparent");        }        gLogI.log(kDebug_ANPLogType, "END: testing bitmap transparency");        mFinishedStageThree = true;    }}

void NavigationPlugin::draw(ANPCanvas* canvas) {    NPP instance = this->inst();    PluginObject *obj = (PluginObject*) instance->pdata;    const int W = obj->window->width;    const int H = obj->window->height;    const int Wm = W/2;    const int Hm = H/2;    // color the plugin canvas    gCanvasI.drawColor(canvas, (m_hasFocus) ? 0xFFCDCDCD : 0xFF545454);    // draw the nav up box (5 px from the top edge)    m_navUp.left = Wm - 15;    m_navUp.top = 5;    m_navUp.right = m_navUp.left + 30;    m_navUp.bottom = m_navUp.top + 30;    gCanvasI.drawRect(canvas, &m_navUp, getPaint(&m_navUp));    // draw the nav down box (5 px from the bottom edge)    m_navDown.left = Wm - 15;    m_navDown.top = H - (30 + 5);    m_navDown.right = m_navDown.left + 30;    m_navDown.bottom = m_navDown.top + 30;    gCanvasI.drawRect(canvas, &m_navDown, getPaint(&m_navDown));    // draw the nav left box (5 px from the left edge)    m_navLeft.left = 5;    m_navLeft.top = Hm - 15;    m_navLeft.right = m_navLeft.left + 30;    m_navLeft.bottom = m_navLeft.top + 30;    gCanvasI.drawRect(canvas, &m_navLeft, getPaint(&m_navLeft));    // draw the nav right box (5 px from the right edge)    m_navRight.left = W - (30 + 5);    m_navRight.top = Hm - 15;    m_navRight.right = m_navRight.left + 30;    m_navRight.bottom = m_navRight.top + 30;    gCanvasI.drawRect(canvas, &m_navRight, getPaint(&m_navRight));    // draw the nav center box    m_navCenter.left = Wm - 15;    m_navCenter.top = Hm - 15;    m_navCenter.right = m_navCenter.left + 30;    m_navCenter.bottom = m_navCenter.top + 30;    gCanvasI.drawRect(canvas, &m_navCenter, getPaint(&m_navCenter));    gLogI.log(kDebug_ANPLogType, "----%p Drawing Plugin", inst());}

VideoPlugin::VideoPlugin(NPP inst, const char * path) : SurfaceSubPlugin(inst) {    // initialize the drawing surface    m_surface = NULL;    //register for touch events    ANPEventFlags flags = kTouch_ANPEventFlag;    NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);    if (err != NPERR_NO_ERROR) {        gLogI.log(kError_ANPLogType, "Error selecting input events.");    }    if (path != NULL) {        strcpy(mFilepath, path);    }}

// called by PluginAppletViewer.java nativeInvokeNative()static jboolean invokeNative(JNIEnv* jniEnv,                             jobject thiz,            // TODO ???                             jint jnpp,               // root npp instance given to jni-bridge::surfaceCreated() -> handed over to DexLoader.loadDexInit()                             jint jsobj_addr,         // via JsObject from pluginAppletViewer.getWindow();                             jstring jmethodName,     // may be null                             jobject args[]){  NPP npp = (NPP)jnpp;  if(npp)  {    if(jniEnv && browser && browser->pluginthreadasynccall)    {      InvokeNativeObject* invokeNativeObject = (InvokeNativeObject*)malloc(sizeof(InvokeNativeObject));      if(invokeNativeObject)      {        const char* methodName = NULL;        if(jmethodName)          methodName = jniEnv->GetStringUTFChars(jmethodName, NULL);//        if(methodName)//          gLogI.log(npp, kDebug_ANPLogType, "jni-bridge invokeNative() npp=%p jsobj_addr=%p methodname=%s ...",npp,jsobj_addr,methodName);//        else//          gLogI.log(npp, kDebug_ANPLogType, "jni-bridge invokeNative() npp=%p jsobj_addr=%p ...",npp,jsobj_addr);        bzero(invokeNativeObject, sizeof(InvokeNativeObject));        invokeNativeObject->npp = npp;        invokeNativeObject->jsobj = (NPObject*)jsobj_addr;        if(methodName)          strcpy(invokeNativeObject->methodName,methodName);        //invokeNativeObject->args = args;    // todo        //gLogI.log(npp, kDebug_ANPLogType, "jni-bridge invokeNative() npp=%p jsobj=%p use pluginthreadasynccall()...",npp,invokeNativeObject->jsobj);        browser->pluginthreadasynccall(npp, &invokeNativeAsync, (void*)invokeNativeObject);        // invokeNativeObject may now be freed        //gLogI.log(npp, kDebug_ANPLogType, "jni-bridge invokeNative() called ... ");        if(jmethodName)          jniEnv->ReleaseStringUTFChars(jmethodName, methodName);        //gLogI.log(npp, kDebug_ANPLogType, "jni-bridge invokeNative() done");        return true;      }    }    gLogI.log(npp, kDebug_ANPLogType, "jni-bridge invokeNative() done fail");  }  return false;}

NavigationPlugin::NavigationPlugin(NPP inst) : SubPlugin(inst) {    m_hasFocus = false;    m_activeNav = NULL;    m_paintDisabled = gPaintI.newPaint();    gPaintI.setFlags(m_paintDisabled, gPaintI.getFlags(m_paintDisabled) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintDisabled, 0xFFFFFFFF);    m_paintActive = gPaintI.newPaint();    gPaintI.setFlags(m_paintActive, gPaintI.getFlags(m_paintActive) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintActive, 0xFFFFFF00);    //register for key events    ANPEventFlags flags = kKey_ANPEventFlag;    NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);    if (err != NPERR_NO_ERROR) {        gLogI.log(kError_ANPLogType, "Error selecting input events.");    }}

FormPlugin::FormPlugin(NPP inst) : SubPlugin(inst) {    m_hasFocus = false;    m_activeInput = NULL;    memset(&m_usernameInput, 0, sizeof(m_usernameInput));    memset(&m_passwordInput, 0, sizeof(m_passwordInput));    m_usernameInput.text[0] = '/0';    m_usernameInput.charPtr = 0;    m_passwordInput.text[0] = '/0';    m_passwordInput.charPtr = 0;    m_paintInput = gPaintI.newPaint();    gPaintI.setFlags(m_paintInput, gPaintI.getFlags(m_paintInput) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintInput, 0xFFFFFFFF);    m_paintActive = gPaintI.newPaint();    gPaintI.setFlags(m_paintActive, gPaintI.getFlags(m_paintActive) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintActive, 0xFFFFFF00);    m_paintText = gPaintI.newPaint();    gPaintI.setFlags(m_paintText, gPaintI.getFlags(m_paintText) | kAntiAlias_ANPPaintFlag);    gPaintI.setColor(m_paintText, 0xFF000000);    gPaintI.setTextSize(m_paintText, 18);    ANPTypeface* tf = gTypefaceI.createFromName("serif", kItalic_ANPTypefaceStyle);    gPaintI.setTypeface(m_paintText, tf);    gTypefaceI.unref(tf);    //register for key and visibleRect events    ANPEventFlags flags = kKey_ANPEventFlag;    NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);    if (err != NPERR_NO_ERROR) {        gLogI.log(kError_ANPLogType, "Error selecting input events.");    }}