NativeActivity.hpp

Go to the documentation of this file.

#ifndef __blip_NativeActivity_hpp
#define __blip_NativeActivity_hpp

#include <blip/Blip.hpp>

#include <commonc++/Buffer.h++>
#include <commonc++/ConditionVar.h++>
#include <commonc++/JavaException.h++>
#include <commonc++/Mutex.h++>
#include <commonc++/Pipe.h++>
#include <commonc++/ScopedPtr.h++>
#include <commonc++/String.h++>
#include <commonc++/Thread.h++>

CCXX_FWD_DECL(JavaVirtualMachine);

#include <android/native_activity.h>

struct AInputQueue;
struct ANativeActivity;
struct ANativeWindow;

namespace blip {

class AssetManager;
class DeviceConfiguration;
class Event;
class InputEventQueue;
class Intent;
class JavaGlue;
class KeyEvent;
class Looper;
class MotionEvent;
class Rectangle;
class RenderingContext;
class SensorEvent;
class SensorManager;
class StorageManager;
class TimerEvent;
class TimerManager;
class Window;

struct NativeActivityRequest;
typedef void* NativeContext;

class NativeActivity : private ccxx::Thread
{
  friend void blip_send_request(ANativeActivity*, NativeActivityRequest*);
  friend void blip_main(ANativeActivity*, void*, size_t, NativeActivity*);
  friend void blip_exit(NativeActivity*);
  public:

  virtual ~NativeActivity();

  protected:

  NativeActivity(NativeContext context);

  virtual void run();
  void sleep(timespan_ms_t msec);

  virtual void onCreate(ccxx::ByteBuffer* buffer);

  virtual void onStart();

  virtual void onResume();

  virtual void onPause();

  virtual void onStop();

  virtual void onDestroy();

  virtual void onSaveInstanceState(ccxx::ByteBuffer* buffer);

  virtual void onConfigurationChanged();

  void finish();

  virtual bool onKeyEvent(const KeyEvent& event);

  virtual bool onMotionEvent(const MotionEvent& event);

  virtual void onSensorEvent(const SensorEvent& event);

  virtual void onTimerEvent(const TimerEvent& event);

  virtual void onIdle() = 0;

  virtual void onWindowFocusChanged(bool hasFocus);

  virtual void onWindowCreated();

  virtual void onWindowDestroyed();

  virtual void onWindowResized();

  virtual void onWindowRedrawNeeded();

  virtual void onContentRectChanged(const Rectangle &rect);

  virtual void onLowMemory();

  AssetManager* getAssetManager();

  inline const DeviceConfiguration* getDeviceConfiguration()
  { return(_config.get()); }

  inline ccxx::JavaVirtualMachine* getJavaVirtualMachine()
  { return(_jvm.get()); }

  inline RenderingContext* getRenderingContext()
  { return(_renderingContext.get()); }

  SensorManager* getSensorManager();

  StorageManager* getStorageManager();

  TimerManager* getTimerManager();

  inline Window* getWindow()
  { return(_window.get()); }

  inline const Intent& getIntent()
  { return(*(_intent.get())); }

  Intent* newIntent();

  void startActivity(Intent* intent);

  ccxx::String getInternalDataPath() const;

  ccxx::String getExternalDataPath() const;

  void showSoftInput(bool forced = false);

  void hideSoftInput();

  private:

  void init();
  void setInputEventQueue(AInputQueue* queue);
  void deleteInputEventQueue();
  void updateConfiguration();
  void setWindow(ANativeWindow* window);
  void deleteWindow();

  void postRequest(NativeActivityRequest* request);
  bool processRequest();
  void processTimers();

  ANativeActivity* _activity;
  ccxx::ScopedPtr<InputEventQueue> _inputEventQueue;
  ccxx::ScopedPtr<SensorManager> _sensorManager;
  ccxx::ScopedPtr<DeviceConfiguration> _config;
  ccxx::ScopedPtr<AssetManager> _assetManager;
  ccxx::ScopedPtr<StorageManager> _storageManager;
  ccxx::ScopedPtr<TimerManager> _timerManager;
  ccxx::ScopedPtr<Window> _window;
  ccxx::ScopedPtr<RenderingContext> _renderingContext;
  ccxx::ScopedPtr<ccxx::JavaVirtualMachine> _jvm;
  ccxx::ScopedPtr<JavaGlue> _java;
  ccxx::ScopedPtr<Intent> _intent;
  ccxx::ScopedPtr<Looper> _looper;
  ccxx::Mutex _mutex;
  ccxx::ConditionVar _cond;
  ccxx::Pipe _eventPipe;
  ccxx::Pipe _timerPipe;
  NativeActivityRequest* _request;
  byte_t* _savedState;
  uint_t _savedStateSize;
  bool _running;
  bool _focused;

  CCXX_COPY_DECLS(NativeActivity);
};

extern void blip_main(ANativeActivity* activity, void* savedState,
                      size_t savedStateSize, NativeActivity* object);

} // namespace blip

#define EXPORT_NATIVE_ACTIVITY(CLASS, FUNCTION)                         \
  extern "C" {                                                          \
    void FUNCTION(ANativeActivity* activity,                            \
                  void* savedState,                                     \
                  size_t savedStateSize)                                \
    {                                                                   \
      blip::blip_main(activity, savedState, savedStateSize,             \
                      new CLASS((void*)activity));                      \
    }                                                                   \
  };

#endif // __blip_NativeActivity_hpp