com.googlecode.gwtphonegap.client.PhoneGapStandardImpl.java Source code

Java tutorial

Introduction

Here is the source code for com.googlecode.gwtphonegap.client.PhoneGapStandardImpl.java

Source

/*
 * Copyright 2010 Daniel Kurka
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.googlecode.gwtphonegap.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Timer;
import com.google.web.bindery.event.shared.EventBus;
import com.google.web.bindery.event.shared.HandlerRegistration;
import com.google.web.bindery.event.shared.SimpleEventBus;

import com.googlecode.gwtphonegap.client.accelerometer.Accelerometer;
import com.googlecode.gwtphonegap.client.camera.Camera;
import com.googlecode.gwtphonegap.client.capture.Capture;
import com.googlecode.gwtphonegap.client.compass.Compass;
import com.googlecode.gwtphonegap.client.connection.Connection;
import com.googlecode.gwtphonegap.client.contacts.Contacts;
import com.googlecode.gwtphonegap.client.device.Device;
import com.googlecode.gwtphonegap.client.event.Event;
import com.googlecode.gwtphonegap.client.file.File;
import com.googlecode.gwtphonegap.client.geolocation.Geolocation;
import com.googlecode.gwtphonegap.client.globalization.Globalization;
import com.googlecode.gwtphonegap.client.inappbrowser.InAppBrowser;
import com.googlecode.gwtphonegap.client.log.PhoneGapLog;
import com.googlecode.gwtphonegap.client.log.PhoneGapLogStandardImpl;
import com.googlecode.gwtphonegap.client.media.MediaModule;
import com.googlecode.gwtphonegap.client.notification.Notification;
import com.googlecode.gwtphonegap.client.plugins.PhoneGapPlugin;
import com.googlecode.gwtphonegap.client.splashscreen.SplashScreen;

import java.util.HashMap;
import java.util.Map;

public class PhoneGapStandardImpl implements PhoneGap {

    private static final int INIT_TICK = 10;

    private Device device;

    private Accelerometer accelerometer;
    private Camera camera;
    private Geolocation geolocation;
    private Notification notification;
    private Contacts contacts;
    private File file;
    private Connection connection;
    private Event event;
    private MediaModule mediaModule;
    private Compass compass;
    private Capture capture;
    private SplashScreen splashScreen;
    private InAppBrowser inAppBrowser;

    private Map<String, PhoneGapPlugin> plugins = new HashMap<String, PhoneGapPlugin>();

    private boolean hasHandlers = false;
    private EventBus handlerManager = new SimpleEventBus();

    private PhoneGapLogStandardImpl phoneGapLog;

    private boolean deviceReady;

    private Globalization globalization;

    public PhoneGapStandardImpl() {
        // log configures it self
        getLog();

        setupReadyHook();
    }

    public PhoneGapLog getLog() {
        if (phoneGapLog == null) {
            phoneGapLog = new PhoneGapLogStandardImpl();
        }
        return phoneGapLog;
    }

    @Override
    public boolean isPhoneGapInitialized() {
        return deviceReady;
    }

    @Override
    public void initializePhoneGap() {
        initializePhoneGap(10000);
    }

    @Override
    public void initializePhoneGap(final int timeoutInMs) {

        final long end = System.currentTimeMillis() + timeoutInMs;
        if (isPhoneGapInitialized()) {

            firePhoneGapAvailable();

        } else {
            Timer timer = new Timer() {

                @Override
                public void run() {
                    if (isPhoneGapInitialized()) {
                        firePhoneGapAvailable();
                        return;
                    }

                    if (System.currentTimeMillis() - end > 0) {
                        handlerManager.fireEvent(new PhoneGapTimeoutEvent());
                    } else {
                        schedule(INIT_TICK);
                    }

                }
            };

            timer.schedule(INIT_TICK);
        }
    }

    @Override
    public HandlerRegistration addHandler(PhoneGapAvailableHandler handler) {
        hasHandlers = true;
        return handlerManager.addHandler(PhoneGapAvailableEvent.TYPE, handler);
    }

    @Override
    public HandlerRegistration addHandler(PhoneGapTimeoutHandler handler) {
        hasHandlers = true;
        return handlerManager.addHandler(PhoneGapTimeoutEvent.TYPE, handler);
    }

    @Override
    public Device getDevice() {
        if (device == null) {
            device = constructDevice();
        }
        return device;
    }

    @Override
    public Accelerometer getAccelerometer() {
        if (accelerometer == null) {
            accelerometer = constructAccelerometer();
        }
        return accelerometer;
    }

    @Override
    public Camera getCamera() {
        if (camera == null) {
            camera = constructCamera();
        }
        return camera;
    }

    @Override
    public Geolocation getGeolocation() {
        if (geolocation == null) {
            geolocation = constructGeolocation();
        }
        return geolocation;
    }

    @Override
    public Notification getNotification() {
        if (notification == null) {
            notification = constructNotification();
        }
        return notification;
    }

    private void firePhoneGapAvailable() {
        if (!getDevice().isAvailable()) {
            log("Device API is not available - logging will not work");
            log("e.g.: plugman install --platform android  --project ./platforms/android/ --plugin org.apache.cordova.device");
        } else {
            phoneGapLog.setClientId(getDevice().getUuid());
        }
        handlerManager.fireEvent(new PhoneGapAvailableEvent());
    }

    @Override
    public Contacts getContacts() {
        if (contacts == null) {
            contacts = constructContacts();
        }
        return contacts;
    }

    @Override
    public PhoneGapPlugin getPluginById(String id) {
        return plugins.get(id);
    }

    @Override
    public void loadPlugin(String id, PhoneGapPlugin instance) {
        if (plugins.containsKey(id)) {
            throw new IllegalStateException("id is already in use");
        }

        plugins.put(id, instance);
    }

    @Override
    public File getFile() {
        if (file == null) {
            file = constructFile();
        }
        return file;
    }

    @Override
    public Connection getConnection() {
        if (connection == null) {
            connection = constructConnection();
        }
        return connection;
    }

    @Override
    public Event getEvent() {
        hasHandlers = true;
        if (event == null) {
            event = constructEvent();
        }
        return event;
    }

    @Override
    public native boolean exitApp() /*-{
                                    if ($wnd.navigator.app != null) {
                                    if ($wnd.navigator.app.exitApp != null) {
                                    $wnd.navigator.app.exitApp();
                                    return true;
                                    }
                                    }
                                    return false;
                                        
                                    }-*/;

    @Override
    public MediaModule getMedia() {
        if (mediaModule == null) {
            mediaModule = constructMediaModule();
        }
        return mediaModule;
    }

    @Override
    public Compass getCompass() {
        if (compass == null) {
            compass = constructCompass();
        }
        return compass;
    }

    @Override
    public Capture getCapture() {
        if (capture == null) {
            capture = constructCapture();
        }
        return capture;
    }

    @Override
    public SplashScreen getSplashScreen() {
        if (splashScreen == null) {
            splashScreen = constructSplashscreen();
        }
        return splashScreen;
    }

    @Override
    public boolean isPhoneGapDevice() {
        return true;
    }

    protected Device constructDevice() {
        return GWT.create(Device.class);
    }

    protected Accelerometer constructAccelerometer() {
        return GWT.create(Accelerometer.class);
    }

    protected Camera constructCamera() {
        return GWT.create(Camera.class);
    }

    protected Geolocation constructGeolocation() {
        return GWT.create(Geolocation.class);
    }

    protected Notification constructNotification() {
        return GWT.create(Notification.class);
    }

    protected Capture constructCapture() {
        return GWT.create(Capture.class);
    }

    protected SplashScreen constructSplashscreen() {
        return GWT.create(SplashScreen.class);
    }

    protected Compass constructCompass() {
        return GWT.create(Compass.class);
    }

    protected MediaModule constructMediaModule() {
        return GWT.create(MediaModule.class);
    }

    protected Event constructEvent() {
        Event event = GWT.create(Event.class);
        event.setEventBus(handlerManager);
        return event;
    }

    protected Connection constructConnection() {
        return GWT.create(Connection.class);
    }

    protected File constructFile() {
        return GWT.create(File.class);
    }

    protected Contacts constructContacts() {
        return GWT.create(Contacts.class);
    }

    protected void nativeDeviceReady() {
        deviceReady = true;
    }

    private native void setupReadyHook() /*-{
                                         var that = this;
                                         var f = function() {
                                         that.@com.googlecode.gwtphonegap.client.PhoneGapStandardImpl::nativeDeviceReady()();
                                         };
                                         $doc.addEventListener("deviceready", $entry(f), false);
                                             
                                         }-*/;

    @Override
    public void setEventBus(EventBus eventBus) {
        assert !hasHandlers : "The handlerManager can not be replaced because it has got handlers";
        handlerManager = eventBus;
        // We force the event construction so as the app can add events directly
        // to the eventBus instead of through the phoneGap.getEvent() method;
        event = constructEvent();
    }

    @Override
    public InAppBrowser getInAppBrowser() {
        if (inAppBrowser == null) {
            inAppBrowser = constructInAppBrowser();
        }
        return inAppBrowser;
    }

    protected InAppBrowser constructInAppBrowser() {
        return GWT.create(InAppBrowser.class);
    }

    @Override
    public Globalization getGlobalization() {
        if (globalization == null) {
            globalization = constructGlobalization();
        }
        return globalization;
    }

    protected Globalization constructGlobalization() {
        return GWT.create(Globalization.class);
    }

    protected native void log(String message) /*-{
                                              $wnd.console.log(message);
                                              }-*/;

}