which access modifiers should be set to a member interface belong to inner-class, and why

In the below posted code, HTEsotericPoliticsOfTheWest is an inner-class, when i attempted to define an interface, eclipse generated an error as the interface is not ststic!
can you please explain why an interface must be declared ststic within the context of an inner-class??

**code:

//This is an inner-class
private class HTEsotericPoliticsOfTheWest extends HandlerThread {

    private final String TAG = HTEsotericPoliticsOfTheWest.class.getSimpleName();
    private Handler _mHandler = null;

    //#constructor(s)
    public HTEsotericPoliticsOfTheWest(String name) {
        super(name);
    }
    public HTEsotericPoliticsOfTheWest(String name, int priority) {
        super(name, priority);
    }

    public void enqueueTaskForNorthGroup(String token) {
        Message msg = Message.obtain();
        msg.obj = token;
    }

	//********ISSUE IS HERE***********
    interface Isynchronizer {
        void filteredNews();
    }

    public void enqueueTaskForEastGroup(String token) {
    }
    //#handlers-instances
    public Handler getInitedHandlerInstanceForNorthGroup() {
        return new Handler(getLooper(), new HandlerCallbackNorthGroup());
    }
    public Handler getInitedHandlerInstanceForEastGroup() {
        return new Handler(getLooper(), new HandlerCallbackEastGroup());
    }

    //#run
    @Override
    public void run() {
        super.run();
        Log.w(TAG, "run");
    }


    @Override
    protected void onLooperPrepared() {
        super.onLooperPrepared();
        Log.w(TAG, "onLooperPrepared");
    }

    //#termination-methods
    @Override
    public boolean quit() {
        return super.quit();
    }

    @Override
    public boolean quitSafely() {
        return super.quitSafely();
    }

    //#handlers-callbacks classes
    private class HandlerCallbackNorthGroup implements Handler.Callback {

        @Override
        public boolean handleMessage(Message msg) {
            String token = (String) msg.obj;
            int s;

            switch (token) {
                case NORTH_GROUP_PRESEDENTIAL_1:
                    s = 3;
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i("", s + " elapsed");
                    break;
                case NORTH_GROUP_EDUCATIONAL_PRIVATE_1:
                    s = 7;
                    try {
                        TimeUnit.SECONDS.sleep(7);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i("", s + " elapsed");
                    break;
                case NORTH_GROUP_GEOGRAPHICAL_1:
                    s = 10;
                    try {
                        TimeUnit.SECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i("", s + " elapsed");
                    break;
                case NORTH_GROUP_MARINE_1:
                    s = 13;
                    try {
                        TimeUnit.SECONDS.sleep(13);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i("", s + " elapsed");
                    break;
            }
            return false;
        }
    }


    //Q:is it achievable/feasible to pass/communicate between two Handlers?one is in the mainAct while the other is in an inner class?
    private class HandlerCallbackEastGroup implements Handler.Callback {

        @Override
        public boolean handleMessage(Message msg) {
            return false;
        }
    }
}

> eclipse generated an error as the interface is not static!

When an interface is nested in another type, it is a static member. The problem, however, is that an inner class may not declare static members. This is the combination that's leading to the error.

On inner classes, the Java Language Specification is even specific about interfaces:

> 8.1.3. Inner Classes and Enclosing Instances
>
> Inner classes may not declare static initializers (§8.7) or member interfaces, or a compile-time error occurs.
>
> Inner classes may not declare static members, unless they are constant variables (§4.12.4), or a compile-time error occurs.

You may be interested to read JLS 14's version which is reworded to specify that a nested interface is implicitly static as a member of the class; and that an inner class is not allowed to declare static (explicitly or implicitly so) members.