summaryrefslogtreecommitdiff
path: root/vcl/android/androidinst.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'vcl/android/androidinst.cxx')
-rw-r--r--vcl/android/androidinst.cxx658
1 files changed, 631 insertions, 27 deletions
diff --git a/vcl/android/androidinst.cxx b/vcl/android/androidinst.cxx
index a7721438e8c3..16a512551c33 100644
--- a/vcl/android/androidinst.cxx
+++ b/vcl/android/androidinst.cxx
@@ -29,18 +29,520 @@
#include <android/androidinst.hxx>
#include <headless/svpdummies.hxx>
#include <generic/gendata.hxx>
+#include <jni.h>
#include <android/log.h>
#include <android/looper.h>
-#include <lo-bootstrap.h>
+#include <osl/detail/android-bootstrap.h>
#include <osl/detail/android_native_app_glue.h>
+#include <rtl/strbuf.hxx>
+
+extern void VCL_DLLPUBLIC plasma_now(const char *msg);
+
+void plasma_now(const char *msg)
+{
+ fprintf (stderr, "Skipped plasma '%s' !\n", msg);
+}
+
+class AndroidSalData : public SalGenericData
+{
+public:
+ AndroidSalData( SalInstance *pInstance ) : SalGenericData( SAL_DATA_ANDROID, pInstance ) {}
+ virtual void ErrorTrapPush() {}
+ virtual bool ErrorTrapPop( bool ) { return false; }
+};
+
+static rtl::OString MotionEdgeFlagsToString(int32_t nFlags)
+{
+ rtl::OStringBuffer aStr;
+ if (nFlags == AMOTION_EVENT_EDGE_FLAG_NONE)
+ aStr.append ("no-edge");
+ if (nFlags & AMOTION_EVENT_EDGE_FLAG_TOP)
+ aStr.append (":top");
+ if (nFlags & AMOTION_EVENT_EDGE_FLAG_BOTTOM)
+ aStr.append (":bottom");
+ if (nFlags & AMOTION_EVENT_EDGE_FLAG_LEFT)
+ aStr.append (":left");
+ if (nFlags & AMOTION_EVENT_EDGE_FLAG_RIGHT)
+ aStr.append (":right");
+ return aStr.makeStringAndClear();
+}
+
+static rtl::OString KeyMetaStateToString(int32_t nFlags)
+{
+ rtl::OStringBuffer aStr;
+ if (nFlags == AMETA_NONE)
+ aStr.append ("no-meta");
+ if (nFlags & AMETA_ALT_ON)
+ aStr.append (":alt");
+ if (nFlags & AMETA_SHIFT_ON)
+ aStr.append (":shift");
+ if (nFlags & AMETA_SYM_ON)
+ aStr.append (":sym");
+ return aStr.makeStringAndClear();
+}
+
+static sal_uInt16 KeyMetaStateToCode(AInputEvent *event)
+{
+ sal_uInt16 nCode = 0;
+ int32_t nFlags = AKeyEvent_getMetaState(event);
+ if (nFlags & AMETA_SHIFT_ON)
+ nCode |= KEY_SHIFT;
+ if (nFlags & AMETA_SYM_ON)
+ nCode |= KEY_MOD1;
+ if (nFlags & AMETA_ALT_ON)
+ nCode |= KEY_MOD2;
+ return nCode;
+}
+
+static sal_uInt16 KeyToCode(AInputEvent *event)
+{
+ sal_uInt16 nCode = 0;
+ switch (AKeyEvent_getKeyCode(event)) {
+#define MAP(a,b) \
+ case AKEYCODE_##a: nCode = KEY_##b; break
+#define MAP_SAME(a) MAP(a,a)
+
+ MAP_SAME(HOME);
+ MAP_SAME(0); MAP_SAME(1); MAP_SAME(2); MAP_SAME(3); MAP_SAME(4);
+ MAP_SAME(5); MAP_SAME(6); MAP_SAME(7); MAP_SAME(8); MAP_SAME(9);
+
+ MAP_SAME(A); MAP_SAME(B); MAP_SAME(C); MAP_SAME(D);
+ MAP_SAME(E); MAP_SAME(F); MAP_SAME(G); MAP_SAME(H);
+ MAP_SAME(I); MAP_SAME(J); MAP_SAME(K); MAP_SAME(L);
+ MAP_SAME(M); MAP_SAME(N); MAP_SAME(O); MAP_SAME(P);
+ MAP_SAME(Q); MAP_SAME(R); MAP_SAME(S); MAP_SAME(T);
+ MAP_SAME(U); MAP_SAME(V); MAP_SAME(W); MAP_SAME(X);
+ MAP_SAME(Y); MAP_SAME(Z);
+
+ MAP_SAME(TAB); MAP_SAME(SPACE); MAP_SAME(COMMA);
+
+ MAP(ENTER,RETURN);
+ MAP(PAGE_UP, PAGEUP);
+ MAP(PAGE_DOWN, PAGEDOWN);
+ MAP(DEL, DELETE);
+ MAP(PERIOD, POINT);
+
+ case AKEYCODE_BACK: // escape ?
+ case AKEYCODE_UNKNOWN:
+ case AKEYCODE_SOFT_LEFT:
+ case AKEYCODE_SOFT_RIGHT:
+ case AKEYCODE_CALL:
+ case AKEYCODE_ENDCALL:
+ case AKEYCODE_STAR:
+ case AKEYCODE_POUND:
+ case AKEYCODE_DPAD_UP:
+ case AKEYCODE_DPAD_DOWN:
+ case AKEYCODE_DPAD_LEFT:
+ case AKEYCODE_DPAD_RIGHT:
+ case AKEYCODE_DPAD_CENTER:
+ case AKEYCODE_VOLUME_UP:
+ case AKEYCODE_VOLUME_DOWN:
+ case AKEYCODE_POWER:
+ case AKEYCODE_CAMERA:
+ case AKEYCODE_CLEAR:
+ case AKEYCODE_ALT_LEFT:
+ case AKEYCODE_ALT_RIGHT:
+ case AKEYCODE_SHIFT_LEFT:
+ case AKEYCODE_SHIFT_RIGHT:
+ case AKEYCODE_SYM:
+ case AKEYCODE_EXPLORER:
+ case AKEYCODE_ENVELOPE:
+ case AKEYCODE_GRAVE:
+ case AKEYCODE_MINUS:
+ case AKEYCODE_EQUALS:
+ case AKEYCODE_LEFT_BRACKET:
+ case AKEYCODE_RIGHT_BRACKET:
+ case AKEYCODE_BACKSLASH:
+ case AKEYCODE_SEMICOLON:
+ case AKEYCODE_APOSTROPHE:
+ case AKEYCODE_SLASH:
+ case AKEYCODE_AT:
+ case AKEYCODE_NUM:
+ case AKEYCODE_HEADSETHOOK:
+ case AKEYCODE_FOCUS: // not widget, but camera focus
+ case AKEYCODE_PLUS:
+ case AKEYCODE_MENU:
+ case AKEYCODE_NOTIFICATION:
+ case AKEYCODE_SEARCH:
+ case AKEYCODE_MEDIA_PLAY_PAUSE:
+ case AKEYCODE_MEDIA_STOP:
+ case AKEYCODE_MEDIA_NEXT:
+ case AKEYCODE_MEDIA_PREVIOUS:
+ case AKEYCODE_MEDIA_REWIND:
+ case AKEYCODE_MEDIA_FAST_FORWARD:
+ case AKEYCODE_MUTE:
+ case AKEYCODE_PICTSYMBOLS:
+ case AKEYCODE_SWITCH_CHARSET:
+ case AKEYCODE_BUTTON_A:
+ case AKEYCODE_BUTTON_B:
+ case AKEYCODE_BUTTON_C:
+ case AKEYCODE_BUTTON_X:
+ case AKEYCODE_BUTTON_Y:
+ case AKEYCODE_BUTTON_Z:
+ case AKEYCODE_BUTTON_L1:
+ case AKEYCODE_BUTTON_R1:
+ case AKEYCODE_BUTTON_L2:
+ case AKEYCODE_BUTTON_R2:
+ case AKEYCODE_BUTTON_THUMBL:
+ case AKEYCODE_BUTTON_THUMBR:
+ case AKEYCODE_BUTTON_START:
+ case AKEYCODE_BUTTON_SELECT:
+ case AKEYCODE_BUTTON_MODE:
+ fprintf (stderr, "un-mapped keycode %d\n", nCode);
+ nCode = 0;
+ break;
+#undef MAP_SAME
+#undef MAP
+ }
+ fprintf (stderr, "mapped %d -> %d\n", AKeyEvent_getKeyCode(event), nCode);
+ return nCode;
+}
+
+static void BlitFrameRegionToWindow(ANativeWindow_Buffer *pOutBuffer,
+ const basebmp::BitmapDeviceSharedPtr& aDev,
+ const ARect &rSrcRect,
+ int nDestX, int nDestY)
+{
+ fprintf (stderr, "Blit frame #2 src %d,%d->%d,%d to position %d, %d\n",
+ rSrcRect.left, rSrcRect.top, rSrcRect.right, rSrcRect.bottom,
+ nDestX, nDestY);
+
+ basebmp::RawMemorySharedArray aSrcData = aDev->getBuffer();
+ basegfx::B2IVector aDevSize = aDev->getSize();
+ sal_Int32 nStride = aDev->getScanlineStride();
+ unsigned char *pSrc = aSrcData.get();
+
+ // FIXME: do some cropping goodness on aSrcRect to ensure no overflows etc.
+ ARect aSrcRect = rSrcRect;
+
+ // FIXME: we have WINDOW_FORMAT_RGB_565 = 4 ...
+
+ for (unsigned int y = 0; y < (unsigned int)(aSrcRect.bottom - aSrcRect.top); y++)
+ {
+ unsigned char *sp = ( pSrc + nStride * (aSrcRect.bottom - aSrcRect.top - y - 1) +
+ aSrcRect.left * 3 /* src pixel size */ );
+
+ switch (pOutBuffer->format) {
+ case WINDOW_FORMAT_RGBA_8888:
+ case WINDOW_FORMAT_RGBX_8888:
+ {
+ unsigned char *dp = ( (unsigned char *)pOutBuffer->bits +
+ pOutBuffer->stride * 4 * (y + nDestY) +
+ nDestX * 4 /* dest pixel size */ );
+ for (unsigned int x = 0; x < (unsigned int)(aSrcRect.right - aSrcRect.left); x++)
+ {
+ dp[x*4 + 0] = sp[x*3 + 2]; // R
+ dp[x*4 + 1] = sp[x*3 + 1]; // G
+ dp[x*4 + 2] = sp[x*3 + 0]; // B
+ dp[x*4 + 3] = 255; // A
+ }
+ break;
+ }
+ case WINDOW_FORMAT_RGB_565:
+ {
+ unsigned char *dp = ( (unsigned char *)pOutBuffer->bits +
+ pOutBuffer->stride * 2 * (y + nDestY) +
+ nDestX * 2 /* dest pixel size */ );
+ for (unsigned int x = 0; x < (unsigned int)(aSrcRect.right - aSrcRect.left); x++)
+ {
+ unsigned char b = sp[x*3 + 0]; // B
+ unsigned char g = sp[x*3 + 1]; // G
+ unsigned char r = sp[x*3 + 2]; // R
+ dp[x*2 + 0] = (r & 0xf8) | (g >> 5);
+ dp[x*2 + 1] = ((g & 0x1c) << 5) | ((b & 0xf8) >> 3);
+ }
+ break;
+ }
+ default:
+ fprintf (stderr, "unknown pixel format %d !\n", pOutBuffer->format);
+ break;
+ }
+ }
+ fprintf (stderr, "done blit!\n");
+}
+
+void AndroidSalInstance::BlitFrameToWindow(ANativeWindow_Buffer *pOutBuffer,
+ const basebmp::BitmapDeviceSharedPtr& aDev)
+{
+ basegfx::B2IVector aDevSize = aDev->getSize();
+ ARect aWhole = { 0, 0, aDevSize.getX(), aDevSize.getY() };
+ BlitFrameRegionToWindow(pOutBuffer, aDev, aWhole, 0, 0);
+}
+
+void AndroidSalInstance::RedrawWindows(ANativeWindow *pWindow)
+{
+ if (!pWindow)
+ return;
+
+ ANativeWindow_Buffer aOutBuffer;
+ memset ((void *)&aOutBuffer, 0, sizeof (aOutBuffer));
+
+// ARect aRect;
+ fprintf (stderr, "pre lock #3\n");
+ int32_t nRet = ANativeWindow_lock(pWindow, &aOutBuffer, NULL);
+ fprintf (stderr, "locked window %d returned " // rect: %d,%d->%d,%d "
+ "buffer: %dx%d stride %d, format %d, bits %p\n",
+ nRet, // aRect.left, aRect.top, aRect.right, aRect.bottom,
+ aOutBuffer.width, aOutBuffer.height, aOutBuffer.stride,
+ aOutBuffer.format, aOutBuffer.bits);
+ if (aOutBuffer.bits != NULL)
+ {
+
+#if 1 // pre-'clean' the buffer with cruft:
+ // hard-code / guess at a format ...
+ int32_t *p = (int32_t *)aOutBuffer.bits;
+ for (int32_t y = 0; y < aOutBuffer.height; y++)
+ {
+ for (int32_t x = 0; x < aOutBuffer.stride; x++)
+ *p++ = (y << 24) + (x << 10) + 0xff ;
+ }
+#endif
+
+ std::list< SalFrame* >::const_iterator it;
+ for ( it = getFrames().begin(); it != getFrames().end(); it++ )
+ {
+ SvpSalFrame *pFrame = static_cast<SvpSalFrame *>(*it);
+
+ if (pFrame->IsVisible())
+ {
+ // FIXME: force a re-draw - this appears not to happen much otherwis
+ pFrame->PostPaint(true);
+ BlitFrameToWindow (&aOutBuffer, pFrame->getDevice());
+ }
+ else // Sucky the frame is invisible - why !?
+ fprintf (stderr, "invisible frame\n");
+ }
+ }
+ else
+ fprintf (stderr, "no buffer for locked window\n");
+ ANativeWindow_unlockAndPost(pWindow);
+
+ fprintf (stderr, "done render!\n");
+ mbQueueReDraw = false;
+}
+
+static const char *app_cmd_name(int cmd)
+{
+ switch (cmd) {
+ case APP_CMD_INPUT_CHANGED: return "INPUT_CHANGED";
+ case APP_CMD_INIT_WINDOW: return "INIT_WINDOW";
+ case APP_CMD_TERM_WINDOW: return "TERM_WINDOW";
+ case APP_CMD_WINDOW_RESIZED: return "WINDOW_RESIZED";
+ case APP_CMD_WINDOW_REDRAW_NEEDED: return "WINDOW_REDRAW_NEEDED";
+ case APP_CMD_CONTENT_RECT_CHANGED: return "CONTENT_RECT_CHANGED";
+ case APP_CMD_GAINED_FOCUS: return "GAINED_FOCUS";
+ case APP_CMD_LOST_FOCUS: return "LOST_FOCUS";
+ case APP_CMD_CONFIG_CHANGED: return "CONFIG_CHANGED";
+ case APP_CMD_LOW_MEMORY: return "LOW_MEMORY";
+ case APP_CMD_START: return "START";
+ case APP_CMD_RESUME: return "RESUME";
+ case APP_CMD_SAVE_STATE: return "SAVE_STATE";
+ case APP_CMD_PAUSE: return "PAUSE";
+ case APP_CMD_STOP: return "STOP";
+ case APP_CMD_DESTROY: return "DESTROY";
+ default:
+ static char buf[10];
+ sprintf(buf, "%d", cmd);
+ return buf;
+ }
+}
+
+void AndroidSalInstance::GetWorkArea( Rectangle& rRect )
+{
+ ANativeWindow *pWindow = mpApp->window;
+ if (!pWindow)
+ rRect = Rectangle( Point( 0, 0 ),
+ Size( 800, 600 ) );
+ else
+ rRect = Rectangle( Point( 0, 0 ),
+ Size( ANativeWindow_getWidth( pWindow ),
+ ANativeWindow_getHeight( pWindow ) ) );
+}
+
+void AndroidSalInstance::onAppCmd (struct android_app* app, int32_t cmd)
+{
+ fprintf (stderr, "app cmd for app %p: %s\n", app, app_cmd_name(cmd));
+ ANativeWindow *pWindow = mpApp->window;
+ switch (cmd) {
+ case APP_CMD_INIT_WINDOW:
+ {
+ ARect aRect = { 0, 0, 0, 0 };
+ aRect.right = ANativeWindow_getWidth(pWindow);
+ aRect.bottom = ANativeWindow_getHeight(pWindow);
+ int nRet = ANativeWindow_setBuffersGeometry(
+ pWindow, ANativeWindow_getWidth(pWindow),
+ ANativeWindow_getHeight(pWindow),
+ WINDOW_FORMAT_RGBA_8888);
+ fprintf (stderr, "we have an app window ! %p %dx%x (%d) set %d\n",
+ pWindow, aRect.right, aRect.bottom,
+ ANativeWindow_getFormat(pWindow), nRet);
+ break;
+ }
+ case APP_CMD_WINDOW_RESIZED:
+ {
+ ARect aRect = { 0, 0, 0, 0 };
+ aRect.right = ANativeWindow_getWidth(pWindow);
+ aRect.bottom = ANativeWindow_getHeight(pWindow);
+ fprintf (stderr, "app window resized to ! %p %dx%x (%d)\n",
+ pWindow, aRect.right, aRect.bottom,
+ ANativeWindow_getFormat(pWindow));
+ break;
+ }
+
+ case APP_CMD_WINDOW_REDRAW_NEEDED:
+ {
+ fprintf (stderr, "redraw needed\n");
+ mbQueueReDraw = true;
+ break;
+ }
+
+ case APP_CMD_CONTENT_RECT_CHANGED:
+ {
+ ARect aRect = mpApp->contentRect;
+ fprintf (stderr, "content rect changed [ k/b popped up etc. ] %d,%d->%d,%d\n",
+ aRect.left, aRect.top, aRect.right, aRect.bottom);
+ break;
+ }
+ default:
+ fprintf (stderr, "unhandled app cmd %d\n", cmd);
+ break;
+ }
+}
+
+int32_t AndroidSalInstance::onInputEvent (struct android_app* app, AInputEvent* event)
+{
+ bool bHandled = false;
+ fprintf (stderr, "input event for app %p, event %p type %d source %d device id %d\n",
+ app, event,
+ AInputEvent_getType(event),
+ AInputEvent_getSource(event),
+ AInputEvent_getDeviceId(event));
+
+ switch (AInputEvent_getType(event))
+ {
+ case AINPUT_EVENT_TYPE_KEY:
+ {
+ int32_t nAction = AKeyEvent_getAction(event);
+ fprintf (stderr, "key event keycode %d '%s' %s\n",
+ AKeyEvent_getKeyCode(event),
+ nAction == AKEY_EVENT_ACTION_DOWN ? "down" :
+ nAction == AKEY_EVENT_ACTION_UP ? "up" : "multiple",
+ KeyMetaStateToString(AKeyEvent_getMetaState(event)).getStr());
+
+ // FIXME: the whole SALEVENT_KEYMODCHANGE stuff is going to be interesting
+ // can we really emit that ? no input method madness required though.
+ sal_uInt16 nEvent;
+ SalKeyEvent aEvent;
+ int64_t nNsTime = AKeyEvent_getEventTime(event);
+
+ nEvent = (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_UP ?
+ SALEVENT_KEYUP : SALEVENT_KEYINPUT);
+ aEvent.mnTime = nNsTime / (1000 * 1000);
+ aEvent.mnCode = KeyToCode(event);
+ aEvent.mnCode |= KeyMetaStateToCode(event);
+ aEvent.mnCharCode = 'a'; // the unicode of it all ...
+ aEvent.mnRepeat = AKeyEvent_getRepeatCount(event);
+
+ SalFrame *pFocus = SvpSalFrame::GetFocusFrame();
+ if (pFocus)
+ bHandled = pFocus->CallCallback( nEvent, &aEvent );
+ else
+ fprintf (stderr, "no focused frame to emit event on\n");
+
+ fprintf( stderr, "bHandled == %s\n", bHandled? "true": "false" );
+
+ // FIXME: queueing full re-draw on key events ...
+ mbQueueReDraw = true;
+ break;
+ }
+ case AINPUT_EVENT_TYPE_MOTION:
+ {
+ size_t nPoints = AMotionEvent_getPointerCount(event);
+ fprintf (stderr, "motion event %d %g,%g %d points: %s\n",
+ AMotionEvent_getAction(event),
+ AMotionEvent_getXOffset(event),
+ AMotionEvent_getYOffset(event),
+ (int)nPoints,
+ MotionEdgeFlagsToString(AMotionEvent_getEdgeFlags(event)).getStr());
+ for (size_t i = 0; i < nPoints; i++)
+ fprintf(stderr, "\t%d: %g,%g - pressure %g\n",
+ (int)i,
+ AMotionEvent_getX(event, i),
+ AMotionEvent_getY(event, i),
+ AMotionEvent_getPressure(event, i));
+
+ SalMouseEvent aMouseEvent;
+ sal_uInt16 nEvent = 0;
+
+ // FIXME: all this filing the nEvent and aMouseEvent has to be cleaned up
+ nEvent = AMotionEvent_getAction(event)? SALEVENT_MOUSEBUTTONUP: SALEVENT_MOUSEBUTTONDOWN;
+
+ aMouseEvent.mnX = AMotionEvent_getXOffset(event);
+ aMouseEvent.mnY = AMotionEvent_getYOffset(event);
+ aMouseEvent.mnTime = 0; // FIXME
+ aMouseEvent.mnCode = 0; // FIXME
+ aMouseEvent.mnButton = MOUSE_LEFT; // FIXME
+
+ SalFrame *pFocus = SvpSalFrame::GetFocusFrame();
+ if (pFocus)
+ bHandled = pFocus->CallCallback( nEvent, &aMouseEvent );
+ else
+ fprintf (stderr, "no focused frame to emit event on\n");
+
+ fprintf( stderr, "bHandled == %s\n", bHandled? "true": "false" );
+
+ break;
+ }
+ default:
+ fprintf (stderr, "unknown input event type %p %d\n",
+ event, AInputEvent_getType(event));
+ break;
+ }
+ return bHandled ? 1 : 0;
+}
+
+AndroidSalInstance *AndroidSalInstance::getInstance()
+{
+ if (!ImplGetSVData())
+ return NULL;
+ AndroidSalData *pData = static_cast<AndroidSalData *>(ImplGetSVData()->mpSalData);
+ if (!pData)
+ return NULL;
+ return static_cast<AndroidSalInstance *>(pData->m_pInstance);
+}
+
+extern "C" {
+ void onAppCmd_cb (struct android_app *app, int32_t cmd)
+ {
+ AndroidSalInstance::getInstance()->onAppCmd(app, cmd);
+ }
+
+ int32_t onInputEvent_cb (struct android_app *app, AInputEvent *event)
+ {
+ return AndroidSalInstance::getInstance()->onInputEvent(app, event);
+ }
+}
AndroidSalInstance::AndroidSalInstance( SalYieldMutex *pMutex )
: SvpSalInstance( pMutex )
+ , mpApp( NULL )
+ , mbQueueReDraw( false )
+ , mxDisplay( EGL_NO_DISPLAY )
+ , mxSurface( EGL_NO_SURFACE )
+ , mxContext( EGL_NO_CONTEXT )
{
- app = lo_get_app();
- fprintf (stderr, "created Android Sal Instance for app %p window %p\n",
- app,
- app ? app->window : NULL);
+ mpApp = lo_get_app();
+ fprintf (stderr, "created Android Sal Instance for app %p window %p thread: %d\n",
+ mpApp,
+ mpApp ? mpApp->window : NULL,
+ (int)pthread_self());
+ if (mpApp)
+ {
+ pthread_mutex_lock (&mpApp->mutex);
+ mpApp->onAppCmd = onAppCmd_cb;
+ mpApp->onInputEvent = onInputEvent_cb;
+ pthread_mutex_unlock (&mpApp->mutex);
+ }
}
AndroidSalInstance::~AndroidSalInstance()
@@ -50,8 +552,9 @@ AndroidSalInstance::~AndroidSalInstance()
void AndroidSalInstance::Wakeup()
{
- if (app && app->looper)
- ALooper_wake (app->looper);
+ fprintf (stderr, "Wakeup alooper\n");
+ if (mpApp && mpApp->looper)
+ ALooper_wake (mpApp->looper);
else
fprintf (stderr, "busted - no global looper\n");
}
@@ -61,20 +564,40 @@ void AndroidSalInstance::DoReleaseYield (int nTimeoutMS)
// release yield mutex
sal_uLong nAcquireCount = ReleaseYieldMutex();
- fprintf (stderr, "DoReleaseYield for %d ms\n", nTimeoutMS);
-// int ALooper_pollOnce(timeoutMs, int* outFd, int* outEvents, void** outData);
+ fprintf (stderr, "DoReleaseYield #3 %d thread: %d ms\n",
+ nTimeoutMS, (int)pthread_self());
+
+ struct android_poll_source *pSource = NULL;
+ int outFd = 0, outEvents = 0;
+
+ if (mbQueueReDraw)
+ nTimeoutMS = 0;
+
+ int nRet;
+ nRet = ALooper_pollAll (nTimeoutMS, &outFd, &outEvents, (void**)&pSource);
+ fprintf (stderr, "ret #6 %d %d %d %p\n", nRet, outFd, outEvents, pSource);
// acquire yield mutex again
AcquireYieldMutex(nAcquireCount);
+
+ if (nRet >= 0)
+ {
+ // Process this event.
+ if (pSource != NULL)
+ pSource->process(mpApp, pSource);
+ }
+
+ if (mbQueueReDraw && mpApp->window)
+ AndroidSalInstance::getInstance()->RedrawWindows (mpApp->window);
}
bool AndroidSalInstance::AnyInput( sal_uInt16 nType )
{
- (void) nType;
- // FIXME: ideally we should check the input queue to avoid being busy ...
- fprintf (stderr, "FIXME: AnyInput returns true\n");
- // app->inputQueue ? ...
- return true;
+ if( (nType & VCL_INPUT_TIMER) != 0 )
+ return CheckTimeout( false );
+ // FIXME: ideally we should check our input queue here ...
+ fprintf (stderr, "FIXME: AnyInput returns false\n");
+ return false;
}
class AndroidSalSystem : public SvpSalSystem {
@@ -84,14 +607,7 @@ public:
virtual int ShowNativeDialog( const rtl::OUString& rTitle,
const rtl::OUString& rMessage,
const std::list< rtl::OUString >& rButtons,
- int nDefButton )
- {
- (void)rButtons; (void)nDefButton;
- __android_log_print(ANDROID_LOG_INFO, "LibreOffice - dialog '%s': '%s'",
- rtl::OUStringToOString(rTitle, RTL_TEXTENCODING_ASCII_US).getStr(),
- rtl::OUStringToOString(rMessage, RTL_TEXTENCODING_ASCII_US).getStr());
- return 0;
- }
+ int nDefButton );
};
SalSystem *AndroidSalInstance::CreateSalSystem()
@@ -99,14 +615,66 @@ SalSystem *AndroidSalInstance::CreateSalSystem()
return new AndroidSalSystem();
}
-class AndroidSalData : public SalGenericData
+class AndroidSalFrame : public SvpSalFrame
{
public:
- AndroidSalData( SalInstance *pInstance ) : SalGenericData( SAL_DATA_ANDROID, pInstance ) {}
- virtual void ErrorTrapPush() {}
- virtual bool ErrorTrapPop( bool ) { return false; }
+ AndroidSalFrame( AndroidSalInstance *pInstance,
+ SalFrame *pParent,
+ sal_uLong nSalFrameStyle,
+ SystemParentData *pSysParent )
+ : SvpSalFrame( pInstance, pParent, nSalFrameStyle, pSysParent )
+ {
+ }
+
+ virtual void GetWorkArea( Rectangle& rRect )
+ {
+ AndroidSalInstance::getInstance()->GetWorkArea( rRect );
+ }
+
+ virtual void UpdateSettings( AllSettings &rSettings )
+ {
+ // Clobber the UI fonts
+#if 0
+ psp::FastPrintFontInfo aInfo;
+ aInfo.m_aFamilyName = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Roboto" ) );
+ aInfo.m_eItalic = ITALIC_NORMAL;
+ aInfo.m_eWeight = WEIGHT_NORMAL;
+ aInfo.m_eWidth = WIDTH_NORMAL;
+ psp::PrintFontManager::get().matchFont( aInfo, rSettings.GetUILocale() );
+#endif
+
+ // FIXME: is 12 point enough ?
+ Font aFont( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Roboto" ) ),
+ Size( 0, 14 ) );
+
+ StyleSettings aStyleSet = rSettings.GetStyleSettings();
+ aStyleSet.SetAppFont( aFont );
+ aStyleSet.SetHelpFont( aFont );
+ aStyleSet.SetMenuFont( aFont );
+ aStyleSet.SetToolFont( aFont );
+ aStyleSet.SetLabelFont( aFont );
+ aStyleSet.SetInfoFont( aFont );
+ aStyleSet.SetRadioCheckFont( aFont );
+ aStyleSet.SetPushButtonFont( aFont );
+ aStyleSet.SetFieldFont( aFont );
+ aStyleSet.SetIconFont( aFont );
+ aStyleSet.SetGroupFont( aFont );
+
+ rSettings.SetStyleSettings( aStyleSet );
+ }
};
+SalFrame *AndroidSalInstance::CreateChildFrame( SystemParentData* pParent, sal_uLong nStyle )
+{
+ return new AndroidSalFrame( this, NULL, nStyle, pParent );
+}
+
+SalFrame *AndroidSalInstance::CreateFrame( SalFrame* pParent, sal_uLong nStyle )
+{
+ return new AndroidSalFrame( this, pParent, nStyle, NULL );
+}
+
+
// All the interesting stuff is slaved from the AndroidSalInstance
void InitSalData() {}
void DeInitSalData() {}
@@ -120,7 +688,7 @@ void SalAbort( const rtl::OUString& rErrorText, bool bDumpCore )
aError = rtl::OUString::createFromAscii("Unknown application error");
::fprintf( stderr, "%s\n", rtl::OUStringToOString(rErrorText, osl_getThreadTextEncoding()).getStr() );
- __android_log_print(ANDROID_LOG_INFO, "SalAbort: '%s'",
+ __android_log_print(ANDROID_LOG_INFO, "LibreOffice", "SalAbort: '%s'",
rtl::OUStringToOString(aError, RTL_TEXTENCODING_ASCII_US).getStr());
if( bDumpCore )
abort();
@@ -148,6 +716,7 @@ SalData::~SalData()
// This is our main entry point:
SalInstance *CreateSalInstance()
{
+ fprintf (stderr, "Android: CreateSalInstance!\n");
AndroidSalInstance* pInstance = new AndroidSalInstance( new SalYieldMutex() );
new AndroidSalData( pInstance );
return pInstance;
@@ -159,4 +728,39 @@ void DestroySalInstance( SalInstance *pInst )
delete pInst;
}
+#include <vcl/msgbox.hxx>
+
+int AndroidSalSystem::ShowNativeDialog( const rtl::OUString& rTitle,
+ const rtl::OUString& rMessage,
+ const std::list< rtl::OUString >& rButtons,
+ int nDefButton )
+{
+ (void)rButtons; (void)nDefButton;
+ fprintf (stderr, "LibreOffice native dialog '%s': '%s'\n",
+ rtl::OUStringToOString(rTitle, RTL_TEXTENCODING_ASCII_US).getStr(),
+ rtl::OUStringToOString(rMessage, RTL_TEXTENCODING_ASCII_US).getStr());
+ __android_log_print(ANDROID_LOG_INFO, "LibreOffice", "Dialog '%s': '%s'",
+ rtl::OUStringToOString(rTitle, RTL_TEXTENCODING_ASCII_US).getStr(),
+ rtl::OUStringToOString(rMessage, RTL_TEXTENCODING_ASCII_US).getStr());
+
+ if (AndroidSalInstance::getInstance() != NULL)
+ {
+ // Does Android have a native dialog ? if not,. we have to do this ...
+
+ // Of course it has. android.app.AlertDialog seems like a good
+ // choice, it even has one, two or three buttons. Naturally,
+ // it intended to be used from Java, so some verbose JNI
+ // horror would be needed to use it directly here. Probably we
+ // want some easier to use magic wrapper, hmm.
+
+ ErrorBox aVclErrBox( NULL, WB_OK, rTitle );
+ aVclErrBox.SetText( rMessage );
+ aVclErrBox.Execute();
+ }
+ else
+ fprintf (stderr, "VCL not initialized\n");
+ return 0;
+}
+
+
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit (git 2.34.1) at 2024-07-12 05:08:18 +0000