RemoteViews

Intent intent = new Intent(this, NotificationActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
builder.setSmallIcon(R.mipmap.ic_launcher)
        .setTicker("hello world")
        .setWhen(System.currentTimeMillis())
        .setContentTitle("notification test")
        .setContentText("this is a notification")
        .setContentIntent(pendingIntent);
Notification notification = builder.build();
notification.flags = Notification.FLAG_AUTO_CANCEL;

NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(1, notification);

Intent intent = new Intent(this, NotificationActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this);

RemoteViews remoteViews = new RemoteViews(getPackageName(), R.layout.item_search_result);
remoteViews.setImageViewResource(R.id.iv_file, R.mipmap.ic_launcher);
remoteViews.setTextViewText(R.id.tv_title, "notification title");
remoteViews.setTextViewText(R.id.tv_desc, "This is a notification");
PendingIntent pendingIntent1 = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
remoteViews.setOnClickPendingIntent(R.id.iv_file, pendingIntent1);

builder.setSmallIcon(R.mipmap.ic_launcher)
        .setTicker("hello world")
        .setWhen(System.currentTimeMillis())
        .setCustomContentView(remoteViews)
        .setContentIntent(pendingIntent);
Notification notification = builder.build();
notification.flags = Notification.FLAG_AUTO_CANCEL;

NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(2, notification);

public class MyAppWidgetProvider extends AppWidgetProvider {

    public static final String CLICK_ACTION = "yorek.demoandtest.remoteview.action.CLICK";

    @Override
    public void onReceive(final Context context, final Intent intent) {
        super.onReceive(context, intent);

        if (!CLICK_ACTION.equals(intent.getAction())) {
            return;
        }

        Toast.makeText(context, "clicked it", Toast.LENGTH_SHORT).show();

        new Thread(new Runnable() {
            @Override
            public void run() {
                Bitmap srcbBitmap = BitmapFactory.decodeResource(context.getResources(), R.mipmap.ic_launcher);
                AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);

                for (int i = 0; i < 37; i++) {
                    float degree = (i * 10) % 360;
                    RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.widget);
                    remoteViews.setImageViewBitmap(R.id.iv_app_widget, rotateBitmap(context, srcbBitmap, degree));

                    Intent clickIntent = new Intent(CLICK_ACTION);
                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, clickIntent, 0);
                    remoteViews.setOnClickPendingIntent(R.id.iv_app_widget, pendingIntent);

                    appWidgetManager.updateAppWidget(new ComponentName(context, MyAppWidgetProvider.class), remoteViews);
                    SystemClock.sleep(30);
                }
            }
        }).start();
    }

    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        super.onUpdate(context, appWidgetManager, appWidgetIds);

        for (int appWidgetId : appWidgetIds) {
            onWidgetUpdate(context, appWidgetManager, appWidgetId);
        }
    }

    private Bitmap rotateBitmap(Context context, Bitmap bitmap, float degree) {
        Matrix matrix = new Matrix();
        matrix.reset();
        matrix.setRotate(degree);
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
    }

    private void onWidgetUpdate(Context context, AppWidgetManager appWidgetManager, int appWidgetId) {
        RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.widget);

        Intent intent = new Intent(CLICK_ACTION);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
        remoteViews.setOnClickPendingIntent(R.id.iv_app_widget, pendingIntent);

        appWidgetManager.updateAppWidget(appWidgetId, remoteViews);
    }
}

/**
 * Implements {@link BroadcastReceiver#onReceive} to dispatch calls to the various
 * other methods on AppWidgetProvider.  
 *
 * @param context The Context in which the receiver is running.
 * @param intent The Intent being received.
 */
// BEGIN_INCLUDE(onReceive)
public void onReceive(Context context, Intent intent) {
    // Protect against rogue update broadcasts (not really a security issue,
    // just filter bad broacasts out so subclasses are less likely to crash).
    String action = intent.getAction();
    if (AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action)) {
        Bundle extras = intent.getExtras();
        if (extras != null) {
            int[] appWidgetIds = extras.getIntArray(AppWidgetManager.EXTRA_APPWIDGET_IDS);
            if (appWidgetIds != null && appWidgetIds.length > 0) {
                this.onUpdate(context, AppWidgetManager.getInstance(context), appWidgetIds);
            }
        }
    } else if (AppWidgetManager.ACTION_APPWIDGET_DELETED.equals(action)) {
        Bundle extras = intent.getExtras();
        if (extras != null && extras.containsKey(AppWidgetManager.EXTRA_APPWIDGET_ID)) {
            final int appWidgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID);
            this.onDeleted(context, new int[] { appWidgetId });
        }
    } else if (AppWidgetManager.ACTION_APPWIDGET_OPTIONS_CHANGED.equals(action)) {
        Bundle extras = intent.getExtras();
        if (extras != null && extras.containsKey(AppWidgetManager.EXTRA_APPWIDGET_ID)
                && extras.containsKey(AppWidgetManager.EXTRA_APPWIDGET_OPTIONS)) {
            int appWidgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID);
            Bundle widgetExtras = extras.getBundle(AppWidgetManager.EXTRA_APPWIDGET_OPTIONS);
            this.onAppWidgetOptionsChanged(context, AppWidgetManager.getInstance(context),
                    appWidgetId, widgetExtras);
        }
    } else if (AppWidgetManager.ACTION_APPWIDGET_ENABLED.equals(action)) {
        this.onEnabled(context);
    } else if (AppWidgetManager.ACTION_APPWIDGET_DISABLED.equals(action)) {
        this.onDisabled(context);
    } else if (AppWidgetManager.ACTION_APPWIDGET_RESTORED.equals(action)) {
        Bundle extras = intent.getExtras();
        if (extras != null) {
            int[] oldIds = extras.getIntArray(AppWidgetManager.EXTRA_APPWIDGET_OLD_IDS);
            int[] newIds = extras.getIntArray(AppWidgetManager.EXTRA_APPWIDGET_IDS);
            if (oldIds != null && oldIds.length > 0) {
                this.onRestored(context, oldIds, newIds);
                this.onUpdate(context, AppWidgetManager.getInstance(context), newIds);
            }
        }
    }
}
// END_INCLUDE(onReceive)

public RemoteViews(String packageName, int layoutId) {
    this(getApplicationInfo(packageName, UserHandle.myUserId()), layoutId);
}

protected RemoteViews(ApplicationInfo application, int layoutId) {
    mApplication = application;
    mLayoutId = layoutId;
    mBitmapCache = new BitmapCache();
    // setup the memory usage statistics
    mMemoryUsageCounter = new MemoryUsageCounter();
    recalculateMemoryUsage();
}

public void setTextViewText(int viewId, CharSequence text) {
    setCharSequence(viewId, "setText", text);
}

public void setCharSequence(int viewId, String methodName, CharSequence value) {
    addAction(new ReflectionAction(viewId, methodName, ReflectionAction.CHAR_SEQUENCE, value));
}

private void addAction(Action a) {
    if (hasLandscapeAndPortraitLayouts()) {
        throw new RuntimeException("RemoteViews specifying separate landscape and portrait" +
                " layouts cannot be modified. Instead, fully configure the landscape and" +
                " portrait layouts individually before constructing the combined layout.");
    }
    if (mActions == null) {
        mActions = new ArrayList<Action>();
    }
    mActions.add(a);

    // update the memory usage stats
    a.updateMemoryUsageEstimate(mMemoryUsageCounter);
}

public View apply(Context context, ViewGroup parent, OnClickHandler handler) {
   RemoteViews rvToApply = getRemoteViewsToApply(context);

   View result = inflateView(context, rvToApply, parent);
   loadTransitionOverride(context, handler);

   rvToApply.performApply(result, parent, handler);

   return result;
}

private View inflateView(Context context, RemoteViews rv, ViewGroup parent) {
    // RemoteViews may be built by an application installed in another
    // user. So build a context that loads resources from that user but
    // still returns the current users userId so settings like data / time formats
    // are loaded without requiring cross user persmissions.
    final Context contextForResources = getContextForResources(context);
    Context inflationContext = new ContextWrapper(context) {
        @Override
        public Resources getResources() {
            return contextForResources.getResources();
        }
        @Override
        public Resources.Theme getTheme() {
            return contextForResources.getTheme();
        }
        @Override
        public String getPackageName() {
            return contextForResources.getPackageName();
        }
    };

    LayoutInflater inflater = (LayoutInflater)
            context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

    // Clone inflater so we load resources from correct context and
    // we don't add a filter to the static version returned by getSystemService.
    inflater = inflater.cloneInContext(inflationContext);
    inflater.setFilter(this);
    View v = inflater.inflate(rv.getLayoutId(), parent, false);
    v.setTagInternal(R.id.widget_frame, rv.getLayoutId());
    return v;
}

private void performApply(View v, ViewGroup parent, OnClickHandler handler) {
   if (mActions != null) {
       handler = handler == null ? DEFAULT_ON_CLICK_HANDLER : handler;
       final int count = mActions.size();
       for (int i = 0; i < count; i++) {
           Action a = mActions.get(i);
           a.apply(v, parent, handler);
       }
   }
}

private void updateNotificationViews(Entry entry, StatusBarNotification sbn) {
   final RemoteViews contentView = entry.cachedContentView;
   final RemoteViews bigContentView = entry.cachedBigContentView;
   final RemoteViews headsUpContentView = entry.cachedHeadsUpContentView;
   final RemoteViews publicContentView = entry.cachedPublicContentView;

   // Reapply the RemoteViews
   contentView.reapply(mContext, entry.getContentView(), mOnClickHandler);
   if (bigContentView != null && entry.getExpandedContentView() != null) {
       bigContentView.reapply(sbn.getPackageContext(mContext),
               entry.getExpandedContentView(),
               mOnClickHandler);
   }
   View headsUpChild = entry.getHeadsUpContentView();
   if (headsUpContentView != null && headsUpChild != null) {
       headsUpContentView.reapply(sbn.getPackageContext(mContext),
               headsUpChild, mOnClickHandler);
   }
   if (publicContentView != null && entry.getPublicContentView() != null) {
       publicContentView.reapply(sbn.getPackageContext(mContext),
               entry.getPublicContentView(), mOnClickHandler);
   }
   // update the contentIntent
   mNotificationClicker.register(entry.row, sbn);

   entry.row.onNotificationUpdated(entry);
   entry.row.resetHeight();
}

// Prepare a local reference to the remote Context so we're ready to
// inflate any requested LayoutParams.
mRemoteContext = getRemoteContext();
int layoutId = remoteViews.getLayoutId();

// If our stale view has been prepared to match active, and the new
// layout matches, try recycling it
if (content == null && layoutId == mLayoutId) {
    try {
        remoteViews.reapply(mContext, mView, mOnClickHandler);
        content = mView;
        recycled = true;
        if (LOGD) Log.d(TAG, "was able to recycle existing layout");
    } catch (RuntimeException e) {
        exception = e;
    }
}

// Try normal RemoteView inflation
if (content == null) {
    try {
        content = remoteViews.apply(mContext, this, mOnClickHandler);
        if (LOGD) Log.d(TAG, "had to inflate new layout");
    } catch (RuntimeException e) {
        exception = e;
    }
}

private final class ReflectionAction extends Action {
    ...
    String methodName;
    int type;
    Object value;

    ReflectionAction(int viewId, String methodName, int type, Object value) {
        this.viewId = viewId;
        this.methodName = methodName;
        this.type = type;
        this.value = value;
    }
    ...
    @Override
    public void apply(View root, ViewGroup rootParent, OnClickHandler handler) {
        final View view = root.findViewById(viewId);
        if (view == null) return;

        Class<?> param = getParameterType();
        if (param == null) {
            throw new ActionException("bad type: " + this.type);
        }

        try {
            getMethod(view, this.methodName, param).invoke(view, wrapArg(this.value));
        } catch (ActionException e) {
            throw e;
        } catch (Exception ex) {
            throw new ActionException(ex);
        }
    }
    ...
}

private class TextViewSizeAction extends Action {
    public TextViewSizeAction(int viewId, int units, float size) {
        this.viewId = viewId;
        this.units = units;
        this.size = size;
    }
    ...
    @Override
    public void apply(View root, ViewGroup rootParent, OnClickHandler handler) {
        final TextView target = (TextView) root.findViewById(viewId);
        if (target == null) return;
        target.setTextSize(units, size);
    }
    ...
    int units;
    float size;
}

private class BitmapReflectionAction extends Action {
    int bitmapId;
    Bitmap bitmap;
    String methodName;

    BitmapReflectionAction(int viewId, String methodName, Bitmap bitmap) {
        this.bitmap = bitmap;
        this.viewId = viewId;
        this.methodName = methodName;
        bitmapId = mBitmapCache.getBitmapId(bitmap);
    }
    ...
    @Override
    public void apply(View root, ViewGroup rootParent,
            OnClickHandler handler) throws ActionException {
        ReflectionAction ra = new ReflectionAction(viewId, methodName, ReflectionAction.BITMAP,
                bitmap);
        ra.apply(root, rootParent, handler);
    }
    ...
}

private class SetOnClickPendingIntent extends Action {
    public SetOnClickPendingIntent(int id, PendingIntent pendingIntent) {
        this.viewId = id;
        this.pendingIntent = pendingIntent;
    }
    ...
    @Override
    public void apply(View root, ViewGroup rootParent, final OnClickHandler handler) {
        final View target = root.findViewById(viewId);
        if (target == null) return;

        // If the view is an AdapterView, setting a PendingIntent on click doesn't make much
        // sense, do they mean to set a PendingIntent template for the AdapterView's children?
        if (mIsWidgetCollectionChild) {
            Log.w(LOG_TAG, "Cannot setOnClickPendingIntent for collection item " +
                    "(id: " + viewId + ")");
            ApplicationInfo appInfo = root.getContext().getApplicationInfo();

            // We let this slide for HC and ICS so as to not break compatibility. It should have
            // been disabled from the outset, but was left open by accident.
            if (appInfo != null &&
                    appInfo.targetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN) {
                return;
            }
        }

        // If the pendingIntent is null, we clear the onClickListener
        OnClickListener listener = null;
        if (pendingIntent != null) {
            listener = new OnClickListener() {
                public void onClick(View v) {
                    // Find target view location in screen coordinates and
                    // fill into PendingIntent before sending.
                    final Rect rect = getSourceBounds(v);

                    final Intent intent = new Intent();
                    intent.setSourceBounds(rect);
                    handler.onClickHandler(v, pendingIntent, intent);
                }
            };
        }
        target.setOnClickListener(listener);
    }

    public String getActionName() {
        return "SetOnClickPendingIntent";
    }

    PendingIntent pendingIntent;

    public final static int TAG = 1;
}