PipeWidgetProvider.java

package com.swisscom.safeconnect.widget;

import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.TypedValue;
import android.widget.RemoteViews;

import com.swisscom.safeconnect.R;
import com.swisscom.safeconnect.activity.DashboardActivity;
import com.swisscom.safeconnect.activity.SplashActivity;
import com.swisscom.safeconnect.backend.BackendConnector;
import com.swisscom.safeconnect.model.PlumberSubscriptionResponse;
import com.swisscom.safeconnect.utils.Config;
import com.swisscom.safeconnect.utils.Fonts;

/**
 * Created by cianci on 1/13/15.
 */

public abstract class PipeWidgetProvider extends AppWidgetProvider {
    protected static final String ACTION_START_BTN = "com.swisscom.safeconnect.ACTION_BTN";
    protected static final String ACTION_START_APP = "com.swisscom.safeconnect.ACTION_START_APP";

    protected AppWidgetManager mAppWidgetManager;
    protected RemoteViews mRemoteViews;
    protected int mWidgetId = 0;
    protected int mLayoutId;

    @Override
    public void onEnabled(Context context) {
        super.onEnabled(context);

        getSubscription(context);
    }

    @Override
    public void onUpdate(final Context context, final AppWidgetManager appWidgetManager, final int[] appWidgetIds) {
        Config.getInstance().init(context);

        //Get Subscription information
        getSubscription(context);

        for (int widgetId : appWidgetIds) {
            updateWidget(context, appWidgetManager, widgetId, true);
        }
    }

    @Override
    public void onReceive(final Context context, final Intent intent) {
        final String action = intent.getAction();
        Config.getInstance().init(context);

        if (ACTION_START_BTN.equals(action)) {
            startAction(context);
        } else if (ACTION_START_APP.equals(action)) {
            openApp(context);
        } else if (Config.VPN_CONNECT.equals(action)
                || Config.UPDATE_INCIDENTS.equals(action)
                || Config.UPDATE_SUBSCRIPTION.equals(action)) {
            boolean refreshData = intent.getBooleanExtra(ConnectVpnActivity.KEY_REFRESH_DATA, true);
            doUpdate(context, refreshData);
        } else {
            super.onReceive(context, intent);
        }
    }

    protected void doUpdate(Context ctx, boolean refreshData){
        ComponentName name = new ComponentName(ctx, this.getClass());
        AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(ctx);
        int [] ids = appWidgetManager.getAppWidgetIds(name);
        getSubscription(ctx);

        for (int i = 0; i < ids.length; i++) {
            updateWidget(ctx, appWidgetManager, ids[i], refreshData);
        }
    }

    private void startAction(Context context) {
        //if safe connect is not configured, just open the app
        if (Config.getInstance().getAuthToken().isEmpty()) {
            openApp(context);
        }
        //no subscription available - open subscription view
        else if (Config.getInstance().getSubscriptionValidTill() * 1000 <= System.currentTimeMillis()) {
            openSubscriptions(context);
        } else {
            Intent vpnActivityIntent = new Intent(context, ConnectVpnActivity.class);
            vpnActivityIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
            context.startActivity(vpnActivityIntent);
        }
    }

    private void openApp(Context context){
        Intent vpnActivityIntent = new Intent(context, SplashActivity.class);
        vpnActivityIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(vpnActivityIntent);
    }

    private void openSubscriptions(Context context){
        Intent vpnActivityIntent = new Intent(context, DashboardActivity.class);
        vpnActivityIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        vpnActivityIntent.putExtra(DashboardActivity.KEY_OPEN_SUBSCRIPTIONS, true);
        context.startActivity(vpnActivityIntent);
    }

    /**
     * Creates and returns a new bitmap containing the given text.
     */
    public static Bitmap createTextBitmap(Context context, final String text, final float fontSizeSP, int maxWidth) {
        int fontSizePX = convertDiptoPix(context, fontSizeSP);
        int pad = (fontSizePX / 9);
        Paint paint = getPaint(fontSizePX);
        String[] lines = text.split("\n");

        int yOffset = 0;
        int lineHeight = (int) (fontSizePX * 1.1);
        int totHeight = (int) (fontSizePX * 1.1) * lines.length;

        Bitmap bitmap = Bitmap.createBitmap(maxWidth, totHeight, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);

        for (int i = 0; i < lines.length; ++i) {
            int tWidth = (int) (paint.measureText(lines[i]) + pad * 2);
            float xPos = (maxWidth-tWidth)/2;
            canvas.drawText(lines[i], xPos, fontSizePX + yOffset, paint);
            yOffset = yOffset + lineHeight;
        }

        return bitmap;
    }

    public static int findMaxWidth(Context ctx, String text, String deli, float fontSizeSP){
        int res = 0;

        int fontSizePX = convertDiptoPix(ctx, fontSizeSP);
        int pad = (fontSizePX / 9);
        Paint paint = getPaint(fontSizePX);

        String[] words = text.split(deli);
        for (int i = 0; i < words.length; i++){
            int width = (int) (paint.measureText(words[i]) + pad * 2);
            if (width > res) {
                res = width;
            }
        }

        return res;
    }

    private static int convertDiptoPix(Context context, float dip) {
        int value = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dip, context.getResources().getDisplayMetrics());
        return value;
    }

    private static Paint getPaint(float fontSizePX) {
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setTypeface(Fonts.FONT_NORMAL);
        paint.setColor(Color.WHITE);
        paint.setTextSize(fontSizePX);

        return paint;
    }

    private void getSubscription(Context context) {
        new BackendConnector(context).getOwnSubscription(Config.getInstance().getPhoneNumber(),
                Config.getInstance().getDeviceId(), new BackendConnector.ResponseCallback<PlumberSubscriptionResponse>() {
                    @Override
                    public void onRequestComplete(int statusCode, PlumberSubscriptionResponse result) {
                        if (statusCode == 200) {
                            Config.getInstance().setSubscriptionValidTill(result.getValidTill());
                        }
                    }
                });
    }

    protected void getWidgetData(final Context context, final AppWidgetManager appWidgetManager,
                                 final int widgetId) {
        mAppWidgetManager = appWidgetManager;
        mWidgetId = widgetId;
        mRemoteViews = new RemoteViews(context.getPackageName(), mLayoutId);
    }

    protected void updateCommonPart(final Context context){
        //vpn button or vpn icon
        final PendingIntent piStartVpn = PendingIntent.getBroadcast(context, 0,
                new Intent(context, MalwareStatsWidget.class).setAction(ACTION_START_BTN), 0);
        mRemoteViews.setOnClickPendingIntent(R.id.startVPN, piStartVpn);
        mRemoteViews.setOnClickPendingIntent(R.id.iv_icon, piStartVpn);

        updateToggle();
    }

    protected void updateToggle() {
        //Update widget status
        switch (Config.getInstance().getVpnState()) {
            case CONNECTED:
                mRemoteViews.setImageViewResource(R.id.startVPN, R.drawable.ic_widget_toggle_on);
                break;
            case DISABLED:
                mRemoteViews.setImageViewResource(R.id.startVPN, R.drawable.ic_widget_toggle_off);
                break;
            default:
                mRemoteViews.setImageViewResource(R.id.startVPN, R.drawable.ic_widget_toggle_waiting);
        }
    }

    /**
     * Updates single App Widget
     *
     * @param context {@link android.content.Context}
     * @param appWidgetManager {@link android.appwidget.AppWidgetManager}
     * @param widgetId of current widget
     */
    protected abstract void updateWidget(final Context context,
                                         final AppWidgetManager appWidgetManager,
                                         final int widgetId,
                                         final boolean refreshData);
}