From fd9ff189bab62404f09ad912356d6ec76e99a644 Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Mon, 11 May 2015 15:31:04 +0300
Subject: [PATCH 1/9] List view attaches with weakEventHandler

---
 ui/core/weak-event-listener.d.ts |  2 +-
 ui/list-view/list-view-common.ts | 42 +++++++++++++++++++++-----------
 ui/list-view/list-view.ios.ts    | 15 +++++++++---
 3 files changed, 41 insertions(+), 18 deletions(-)

diff --git a/ui/core/weak-event-listener.d.ts b/ui/core/weak-event-listener.d.ts
index 09e1792bc..1637a062b 100644
--- a/ui/core/weak-event-listener.d.ts
+++ b/ui/core/weak-event-listener.d.ts
@@ -33,7 +33,7 @@ declare module "ui/core/weak-event-listener" {
         /**
          * A string to use as key for key value pair instance.
          */
-        key?: string;
+        key: string;
     }
 
     /**
diff --git a/ui/list-view/list-view-common.ts b/ui/list-view/list-view-common.ts
index 7700f03e9..5d36a53b7 100644
--- a/ui/list-view/list-view-common.ts
+++ b/ui/list-view/list-view-common.ts
@@ -1,4 +1,5 @@
 import observable = require("data/observable");
+import observableArray = require("data/observable-array");
 import view = require("ui/core/view");
 import proxy = require("ui/core/proxy");
 import definition = require("ui/list-view");
@@ -6,32 +7,22 @@ import dependencyObservable = require("ui/core/dependency-observable");
 import builder = require("ui/builder");
 import label = require("ui/label");
 import color = require("color");
+import weakEventListener = require("ui/core/weak-event-listener");
 
 var ITEMS = "items";
 var ITEMTEMPLATE = "itemTemplate";
 var ISSCROLLING = "isScrolling";
 var LISTVIEW = "ListView";
-var ITEMSCHANGED = "_itemsChanged";
-var CHANGE = "change";
 var SEPARATORCOLOR = "separatorColor";
+var WEAKEVENTKEY = "_observableArrayChanged";
 
 export module knownTemplates {
     export var itemTemplate = "itemTemplate";
 }
 
 function onItemsPropertyChanged(data: dependencyObservable.PropertyChangeData) {
-    var listView = <definition.ListView>data.object;
-    var itemsChanged = listView[ITEMSCHANGED];
-
-    if (data.oldValue instanceof observable.Observable) {
-        (<observable.Observable>data.oldValue).off(CHANGE, itemsChanged);
-    }
-
-    if (data.newValue instanceof observable.Observable) {
-        (<observable.Observable>data.newValue).on(CHANGE, itemsChanged);
-    }
-
-    listView.refresh();
+    var listView = <ListView>data.object;
+    listView._onItemsPropertyChanged(data);
 }
 
 function onItemTemplatePropertyChanged(data: dependencyObservable.PropertyChangeData) {
@@ -79,6 +70,7 @@ export class ListView extends view.View implements definition.ListView {
         );
 
     private _itemsChanged: (args: observable.EventData) => void;
+    private _weakEventListenerOptions: weakEventListener.WeakEventListenerOptions;
 
     constructor() {
         super();
@@ -143,6 +135,28 @@ export class ListView extends view.View implements definition.ListView {
         lbl.text = this._getDataItem(index) + "";
         return lbl;
     }
+
+
+    public _onItemsPropertyChanged(data: dependencyObservable.PropertyChangeData) {
+        if (data.oldValue instanceof observable.Observable && this._weakEventListenerOptions) {
+            weakEventListener.WeakEventListener.removeWeakEventListener(this._weakEventListenerOptions);
+            this._weakEventListenerOptions = null;
+        }
+
+        if (data.newValue instanceof observable.Observable) {
+            this._weakEventListenerOptions = {
+                targetWeakRef: new WeakRef(this),
+                sourceWeakRef: new WeakRef(data.newValue),
+                eventName: observableArray.ObservableArray.changeEvent,
+                handler: this._itemsChanged,
+                handlerContext: this,
+                key: WEAKEVENTKEY
+            };
+            weakEventListener.WeakEventListener.addWeakEventListener(this._weakEventListenerOptions);
+        }
+
+        this.refresh();
+    }
 }
 
 function getExports(instance: view.View): any {
diff --git a/ui/list-view/list-view.ios.ts b/ui/list-view/list-view.ios.ts
index ec73bd716..dd5799778 100644
--- a/ui/list-view/list-view.ios.ts
+++ b/ui/list-view/list-view.ios.ts
@@ -151,6 +151,7 @@ export class ListView extends common.ListView {
     private _delegate;
     private _heights: Array<number>;
     private _preparingCell: boolean = false;
+    private _isDataDirty: boolean = false;
 
     constructor() {
         super();
@@ -172,6 +173,9 @@ export class ListView extends common.ListView {
 
     public onLoaded() {
         super.onLoaded();
+        if (this._isDataDirty) {
+            this.refresh();
+        }
         this._ios.delegate = this._delegate;
     }
 
@@ -185,8 +189,13 @@ export class ListView extends common.ListView {
     }
 
     public refresh() {
-        this._ios.reloadData();
-        this.requestLayout();
+        if (this.isLoaded) {
+            this._ios.reloadData();
+            this.requestLayout();
+            this._isDataDirty = false;
+        } else {
+            this._isDataDirty = true;
+        }
     }
 
     public getHeight(index: number): number {
@@ -242,7 +251,7 @@ export class ListView extends common.ListView {
                 cell.contentView.addSubview(view.ios);
                 this._addView(view);
             }
-            
+
             this._prepareItem(view, indexPath.row);
             cellHeight = this._layoutCell(view, indexPath);
         }

From 0e8ea034c7b57bbc9e52245738d08d948f22035c Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Mon, 11 May 2015 18:57:42 +0300
Subject: [PATCH 2/9] ListView memory leak tests

---
 apps/tests/ui/helper.ts                    |  7 ++-
 apps/tests/ui/list-view/list-view-tests.ts | 73 +++++++++++++++-------
 2 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/apps/tests/ui/helper.ts b/apps/tests/ui/helper.ts
index 04cff1d1b..bfda9c74e 100644
--- a/apps/tests/ui/helper.ts
+++ b/apps/tests/ui/helper.ts
@@ -11,6 +11,7 @@ import styling = require("ui/styling");
 var DELTA = 0.1;
 
 export var ASYNC = 0.2;
+export var MEMORY_ASYNC = 2;
 
 export function do_PageTest(test: (views: Array<view.View>) => void, content: view.View, secondView: view.View, thirdView: view.View) {
     var newPage: page.Page;
@@ -33,7 +34,7 @@ export function do_PageTest(test: (views: Array<view.View>) => void, content: vi
 export function do_PageTest_WithButton(test: (views: Array<view.View>) => void) {
     var newPage: page.Page;
     var btn: button.Button;
-    var pageFactory = function(): page.Page {
+    var pageFactory = function (): page.Page {
         newPage = new page.Page();
         btn = new button.Button();
         newPage.content = btn;
@@ -76,7 +77,7 @@ export function do_PageTest_WithStackLayout_AndButton(test: (views: Array<view.V
 
 export function do_PageTest_WithStackLayout_AndButton_NavigatedBack(test: (views: Array<view.View>) => void,
     assert: (views: Array<view.View>) => void) {
-    
+
     var newPage: page.Page;
     var stackLayout;
     var btn;
@@ -188,7 +189,7 @@ export function buildUIWithWeakRefAndInteract<T extends view.View>(createFunc: (
 
     try {
         navigate(pageFactory);
-        TKUnit.waitUntilReady(() => { return testFinished; });
+        TKUnit.waitUntilReady(() => { return testFinished; }, MEMORY_ASYNC);
     }
     finally {
         goBack();
diff --git a/apps/tests/ui/list-view/list-view-tests.ts b/apps/tests/ui/list-view/list-view-tests.ts
index 5522104d9..c8562b228 100644
--- a/apps/tests/ui/list-view/list-view-tests.ts
+++ b/apps/tests/ui/list-view/list-view-tests.ts
@@ -430,28 +430,28 @@ export function test_loadMoreItems_not_raised_when_showing_many_items() {
 }
 
 export function test_usingAppLevelConvertersInListViewItems() {
-	var listView = new listViewModule.ListView();
+    var listView = new listViewModule.ListView();
 
-	var dateConverter = function (value, format) {
-		var result = format;
-		var day = value.getDate();
-		result = result.replace("DD", month < 10 ? "0" + day : day);
-		var month = value.getMonth() + 1;
-		result = result.replace("MM", month < 10 ? "0" + month : month);
-		result = result.replace("YYYY", value.getFullYear());
-		return result;
-	};
+    var dateConverter = function (value, format) {
+        var result = format;
+        var day = value.getDate();
+        result = result.replace("DD", month < 10 ? "0" + day : day);
+        var month = value.getMonth() + 1;
+        result = result.replace("MM", month < 10 ? "0" + month : month);
+        result = result.replace("YYYY", value.getFullYear());
+        return result;
+    };
 
-	app.resources["dateConverter"] = dateConverter;
+    app.resources["dateConverter"] = dateConverter;
 
     var data = new observableArray.ObservableArray();
 
-	data.push({date: new Date()});
+    data.push({ date: new Date() });
 
     function testAction(views: Array<viewModule.View>) {
-		listView.itemTemplate = "<Label id=\"testLabel\" text=\"{{ date, date | dateConverter('DD.MM.YYYY') }}\" />";
+        listView.itemTemplate = "<Label id=\"testLabel\" text=\"{{ date, date | dateConverter('DD.MM.YYYY') }}\" />";
         listView.items = data;
-		
+
         TKUnit.wait(ASYNC);
         var nativeElementText = getTextFromNativeElementAt(listView, 0);
 
@@ -501,6 +501,33 @@ export function test_BindingListViewToASimpleArrayWithExpression() {
     helper.buildUIAndRunTest(listView, testAction);
 }
 
+export function test_no_memory_leak_when_items_is_regular_array() {
+    var createFunc = function (): listViewModule.ListView {
+        var listView = new listViewModule.ListView();
+        listView.items = FEW_ITEMS;
+        return listView;
+    };
+
+    helper.buildUIWithWeakRefAndInteract(createFunc, (list) => {
+        TKUnit.assert(list.isLoaded, "ListView should be loaded here");
+    });
+}
+
+export function test_no_memory_leak_when_items_is_observable_array() {
+    // Keep the reference to the observable array to test the weakEventListener 
+    var colors = new observableArray.ObservableArray(["red", "green", "blue"]);
+
+    var createFunc = function (): listViewModule.ListView {
+        var listView = new listViewModule.ListView();
+        listView.items = colors;
+        return listView;
+    };
+
+    helper.buildUIWithWeakRefAndInteract(createFunc, (list) => {
+        TKUnit.assert(list.isLoaded, "ListView should be loaded here");
+    });
+}
+
 function loadViewWithItemNumber(args: listViewModule.ItemEventData) {
     if (!args.view) {
         args.view = new labelModule.Label();
@@ -509,16 +536,16 @@ function loadViewWithItemNumber(args: listViewModule.ItemEventData) {
 }
 
 function getTextFromNativeElementAt(listView: listViewModule.ListView, index: number): any {
-	if (listView.android) {
-		var nativeElement = listView.android.getChildAt(index);
-		if (nativeElement instanceof android.view.ViewGroup) {
-			return (<android.widget.TextView>(<any>nativeElement.getChildAt(0))).getText();
-		}
+    if (listView.android) {
+        var nativeElement = listView.android.getChildAt(index);
+        if (nativeElement instanceof android.view.ViewGroup) {
+            return (<android.widget.TextView>((<any>nativeElement).getChildAt(0))).getText();
+        }
         return (<android.widget.TextView>nativeElement).getText();
-	}
-	else if (listView.ios) {
-		return listView.ios.visibleCells()[index].contentView.subviews[0].text;
-	}
+    }
+    else if (listView.ios) {
+        return listView.ios.visibleCells()[index].contentView.subviews[0].text;
+    }
 }
 
 function getNativeViewCount(listView: listViewModule.ListView): number {

From 71c9266be3bba60717f604de902dde578a974da1 Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Thu, 14 May 2015 13:45:28 +0300
Subject: [PATCH 3/9] WeakEvents refactoring and used in ListView

---
 CrossPlatformModules.csproj             |   4 +-
 apps/tests/testRunner.ts                |   2 +
 apps/tests/ui/helper.ts                 |  15 +-
 apps/tests/weak-event-listener-tests.ts | 204 ++++++++++++++++++++++++
 ui/button/button-common.ts              |  21 ++-
 ui/core/bindable.ts                     |  66 ++++----
 ui/core/weak-event-listener.d.ts        |  36 +++--
 ui/core/weak-event-listener.ts          | 156 ++++++++++--------
 ui/list-view/list-view-common.ts        |  34 ++--
 ui/text-base/text-base.ts               |  20 +--
 10 files changed, 389 insertions(+), 169 deletions(-)
 create mode 100644 apps/tests/weak-event-listener-tests.ts

diff --git a/CrossPlatformModules.csproj b/CrossPlatformModules.csproj
index d4cfc8abb..d8cab45cf 100644
--- a/CrossPlatformModules.csproj
+++ b/CrossPlatformModules.csproj
@@ -13,6 +13,7 @@
     <IISExpressAnonymousAuthentication />
     <IISExpressWindowsAuthentication />
     <IISExpressUseClassicPipelineMode />
+    <UseGlobalApplicationHostFile />
   </PropertyGroup>
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Cross</Configuration>
@@ -186,6 +187,7 @@
       <DependentUpon>main-page.xml</DependentUpon>
     </TypeScriptCompile>
     <TypeScriptCompile Include="apps\editable-text-demo\model.ts" />
+    <TypeScriptCompile Include="apps\tests\weak-event-listener-tests.ts" />
     <TypeScriptCompile Include="apps\ui-tests-app\pages\i61.ts" />
     <TypeScriptCompile Include="apps\ui-tests-app\pages\i73.ts" />
     <TypeScriptCompile Include="apps\ui-tests-app\pages\gestures.ts" />
@@ -1575,7 +1577,7 @@
           <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
         </WebProjectProperties>
       </FlavorProperties>
-      <UserProperties ui_2scroll-view_2package_1json__JSONSchema="http://json.schemastore.org/package" apps_2editable-text-demo_2package_1json__JSONSchema="http://json.schemastore.org/package" apps_2absolute-layout-demo_2package_1json__JSONSchema="http://json.schemastore.org/package" apps_2gallery-app_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2content-view_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2web-view_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2layouts_2linear-layout_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2layouts_2absolute-layout_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2layouts_2dock-layout_2package_1json__JSONSchema="" ui_2layouts_2grid-layout_2package_1json__JSONSchema="" ui_2layouts_2wrap-layout_2package_1json__JSONSchema="http://json.schemastore.org/package" />
+      <UserProperties ui_2layouts_2wrap-layout_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2layouts_2grid-layout_2package_1json__JSONSchema="" ui_2layouts_2dock-layout_2package_1json__JSONSchema="" ui_2layouts_2absolute-layout_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2layouts_2linear-layout_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2web-view_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2content-view_2package_1json__JSONSchema="http://json.schemastore.org/package" apps_2gallery-app_2package_1json__JSONSchema="http://json.schemastore.org/package" apps_2absolute-layout-demo_2package_1json__JSONSchema="http://json.schemastore.org/package" apps_2editable-text-demo_2package_1json__JSONSchema="http://json.schemastore.org/package" ui_2scroll-view_2package_1json__JSONSchema="http://json.schemastore.org/package" />
     </VisualStudio>
   </ProjectExtensions>
 </Project>
\ No newline at end of file
diff --git a/apps/tests/testRunner.ts b/apps/tests/testRunner.ts
index edff81769..3f522c313 100644
--- a/apps/tests/testRunner.ts
+++ b/apps/tests/testRunner.ts
@@ -68,6 +68,8 @@ allTests["LIST-PICKER"] = require("./ui/list-picker/list-picker-tests");
 allTests["DATE-PICKER"] = require("./ui/date-picker/date-picker-tests");
 allTests["TIME-PICKER"] = require("./ui/time-picker/time-picker-tests");
 allTests["WEB-VIEW"] = require("./ui/web-view/web-view-tests");
+allTests["WEAK-EVENTS"] = require("./weak-event-listener-tests");
+
 if (!isRunningOnEmulator()) {
     allTests["LOCATION"] = require("./location-tests");
 }
diff --git a/apps/tests/ui/helper.ts b/apps/tests/ui/helper.ts
index bfda9c74e..b2ad8b48e 100644
--- a/apps/tests/ui/helper.ts
+++ b/apps/tests/ui/helper.ts
@@ -7,6 +7,7 @@ import TKUnit = require("../TKUnit");
 import utils = require("utils/utils");
 import types = require("utils/types");
 import styling = require("ui/styling");
+import platform = require("platform"); 
 
 var DELTA = 0.1;
 
@@ -174,11 +175,7 @@ export function buildUIWithWeakRefAndInteract<T extends view.View>(createFunc: (
             }
 
             sp.removeChild(weakRef.get());
-            if (newPage.ios) {
-                // Could cause GC on the next call.
-                new ArrayBuffer(4 * 1024 * 1024);
-            }
-            utils.GC();
+            forceGC();
 
             TKUnit.assert(!weakRef.get(), weakRef.get() + " leaked!");
             testFinished = true;
@@ -222,4 +219,12 @@ export function assertAreClose(actual: number, expected: number, message: string
     var delta = Math.floor(density) !== density ? 1.1 : DELTA;
 
     TKUnit.assertAreClose(actual, expected, delta, message);
+}
+
+export function forceGC() {
+    if (platform.device.os === platform.platformNames.ios) {
+        // Could cause GC on the next call.
+        new ArrayBuffer(4 * 1024 * 1024);
+    }
+    utils.GC();
 }
\ No newline at end of file
diff --git a/apps/tests/weak-event-listener-tests.ts b/apps/tests/weak-event-listener-tests.ts
new file mode 100644
index 000000000..96eb01f34
--- /dev/null
+++ b/apps/tests/weak-event-listener-tests.ts
@@ -0,0 +1,204 @@
+import TKUnit = require("./TKUnit");
+import types = require("utils/types");
+import observable = require("data/observable");
+import weakEvents = require("ui/core/weak-event-listener");
+import helper = require("./ui/helper");
+
+export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_source() {
+    TKUnit.assertThrows(() => {
+        weakEvents.WeakEventListener.addWeakEventListener({
+            source: undefined,
+            target: {},
+            handler: emptyHandler,
+            eventName: observable.Observable.propertyChangeEvent
+        });
+    });
+}
+
+export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_target() {
+    TKUnit.assertThrows(() => {
+        weakEvents.WeakEventListener.addWeakEventListener({
+            source: new observable.Observable(),
+            target: undefined,
+            handler: emptyHandler,
+            eventName: observable.Observable.propertyChangeEvent
+        });
+    });
+}
+
+export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_handler() {
+    TKUnit.assertThrows(() => {
+        weakEvents.WeakEventListener.addWeakEventListener({
+            source: new observable.Observable(),
+            target: {},
+            handler: undefined,
+            eventName: observable.Observable.propertyChangeEvent
+        });
+    });
+}
+
+export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_name() {
+    TKUnit.assertThrows(() => {
+        weakEvents.WeakEventListener.addWeakEventListener({
+            source: new observable.Observable(),
+            target: {},
+            handler: emptyHandler,
+            eventName: undefined
+        });
+    });
+}
+
+export function test_addWeakEventListener_listensForEvent() {
+    var source = new observable.Observable();
+    var target = new Object;
+    var callbackCalled = false;
+    var handler = function (args: observable.EventData) {
+        callbackCalled = true;
+    }
+
+    weakEvents.WeakEventListener.addWeakEventListener({
+        source: source,
+        target: target,
+        handler: handler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+
+    source.set("testProp", "some value");
+
+    TKUnit.assert(callbackCalled, "Handler not called.");
+}
+
+export function test_removeWeakEventListener_StopsListeningForEvet() {
+    var source = new observable.Observable();
+    var target = new Object;
+    var callbackCalled = false;
+    var handler = function (args: observable.EventData) {
+        callbackCalled = true;
+    }
+
+    var listenerID = weakEvents.WeakEventListener.addWeakEventListener({
+        source: source,
+        target: target,
+        handler: handler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+
+    weakEvents.WeakEventListener.removeWeakEventListener(listenerID);
+
+    source.set("testProp", "some value");
+    TKUnit.assert(!callbackCalled, "Handler should not be called.");
+}
+
+export function test_handlerIsCalled_WithTargetAsThis() {
+    var source = new observable.Observable();
+    var target = new Object;
+    var callbackCalled = false;
+    var handler = function (args: observable.EventData) {
+        TKUnit.assertEqual(this, target, "this should be the target");
+        callbackCalled = true;
+    }
+
+    weakEvents.WeakEventListener.addWeakEventListener({
+        source: source,
+        target: target,
+        handler: handler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+
+    source.set("testProp", "some value");
+    TKUnit.assert(callbackCalled, "Handler not called.");
+}
+
+export function test_listnerDoesNotRetainTarget() {
+    var source = new observable.Observable();
+    var target = new Object;
+    var callbackCalled = false;
+    var handler = function (args: observable.EventData) {
+        TKUnit.assertEqual(this, target, "this should be the target");
+        callbackCalled = true;
+    }
+
+    weakEvents.WeakEventListener.addWeakEventListener({
+        source: source,
+        target: target,
+        handler: handler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+
+    var targetRef = new WeakRef(target);
+    target = undefined;
+    helper.forceGC();
+
+    TKUnit.assert(!targetRef.get(), "Target should be released after GC");
+}
+
+export function test_listnerDoesNotRetainSource() {
+    var source = new observable.Observable();
+    var target = new Object();
+    var callbackCalled = false;
+    var handler = function (args: observable.EventData) {
+        TKUnit.assertEqual(this, target, "this should be the target");
+        callbackCalled = true;
+    }
+
+    weakEvents.WeakEventListener.addWeakEventListener({
+        source: source,
+        target: target,
+        handler: handler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+
+    var sourceRef = new WeakRef(source);
+    source = undefined;
+    helper.forceGC();
+
+    TKUnit.assert(!sourceRef.get(), "Source should be released after GC");
+}
+
+export function test_listnerIsCleared_WhenTargetIsDead() {
+    var source = new observable.Observable();
+
+    var listenerID = addListenerWithSource(source);
+    helper.forceGC();
+
+    for (var i = 0; i < weakEvents.WeakEventListener.cleanDeadReferencesCountTrigger; i++) {
+        addListenerWithSource(source);
+    }
+
+    TKUnit.assert(types.isUndefined(weakEvents.WeakEventListener._weakEventListeners[listenerID]), "The first listener should be dead by now");
+}
+
+export function test_listnerIsCleared_WhenSourceIsDead() {
+    var target = {};
+
+    var listenerID = addListenerWithTarget(target);
+    helper.forceGC();
+
+    for (var i = 0; i < weakEvents.WeakEventListener.cleanDeadReferencesCountTrigger; i++) {
+        addListenerWithTarget(target);
+    }
+
+    TKUnit.assert(types.isUndefined(weakEvents.WeakEventListener._weakEventListeners[listenerID]), "The first listener should be dead by now");
+}
+
+function addListenerWithSource(source: observable.Observable): number {
+    return weakEvents.WeakEventListener.addWeakEventListener({
+        source: source,
+        target: {},
+        handler: emptyHandler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+}
+
+function addListenerWithTarget(target: any): number {
+    return weakEvents.WeakEventListener.addWeakEventListener({
+        source: new observable.Observable(),
+        target: target,
+        handler: emptyHandler,
+        eventName: observable.Observable.propertyChangeEvent
+    })
+}
+
+function emptyHandler(data: observable.EventData) {
+    // Do nothing.
+}
\ No newline at end of file
diff --git a/ui/button/button-common.ts b/ui/button/button-common.ts
index 222ba14ed..e1d8cfdc6 100644
--- a/ui/button/button-common.ts
+++ b/ui/button/button-common.ts
@@ -33,12 +33,12 @@ function onFormattedTextPropertyChanged(data: dependencyObservable.PropertyChang
 (<proxy.PropertyMetadata>formattedTextProperty.metadata).onSetNativeValue = onFormattedTextPropertyChanged;
 
 export class Button extends view.View implements definition.Button {
-
     public static tapEvent = "tap";
-
     public static textProperty = textProperty;
     public static formattedTextProperty = formattedTextProperty;
 
+    private _formattedTextWeakListenerId: number;
+
     public _onBindingContextChanged(oldValue: any, newValue: any) {
         super._onBindingContextChanged(oldValue, newValue);
         if (this.formattedText) {
@@ -60,20 +60,17 @@ export class Button extends view.View implements definition.Button {
 
     set formattedText(value: formattedString.FormattedString) {
         if (this.formattedText !== value) {
-            var weakEventOptions: weakEventListener.WeakEventListenerOptions = {
-                targetWeakRef: new WeakRef(this),
-                eventName: observable.Observable.propertyChangeEvent,
-                sourceWeakRef: new WeakRef(value),
-                handler: this.onFormattedTextChanged,
-                handlerContext: this,
-                key: "formattedText"
-            };
             if (this.formattedText) {
-                weakEventListener.WeakEventListener.removeWeakEventListener(weakEventOptions);
+                weakEventListener.WeakEventListener.removeWeakEventListener(this._formattedTextWeakListenerId);
             }
             this._setValue(Button.formattedTextProperty, value);
             if (value) {
-                weakEventListener.WeakEventListener.addWeakEventListener(weakEventOptions);
+                this._formattedTextWeakListenerId = weakEventListener.WeakEventListener.addWeakEventListener({
+                    target: this,
+                    source: value,
+                    eventName: observable.Observable.propertyChangeEvent,
+                    handler: this.onFormattedTextChanged
+                });
             }
         }
     }
diff --git a/ui/core/bindable.ts b/ui/core/bindable.ts
index 6a6bf0762..09e728877 100644
--- a/ui/core/bindable.ts
+++ b/ui/core/bindable.ts
@@ -1,7 +1,7 @@
 import observable = require("data/observable");
 import definition = require("ui/core/bindable");
 import dependencyObservable = require("ui/core/dependency-observable");
-import weakEventListener = require("ui/core/weak-event-listener");
+import weakEvents = require("ui/core/weak-event-listener");
 import appModule = require("application");
 import types = require("utils/types");
 import trace = require("trace");
@@ -108,7 +108,7 @@ export class Bindable extends dependencyObservable.DependencyObservable implemen
             }
 
             trace.write(
-                "Binding target: " + binding.target.get() + 
+                "Binding target: " + binding.target.get() +
                 " targetProperty: " + binding.options.targetProperty +
                 " to the changed context: " + newValue, trace.categories.Binding);
             binding.unbind();
@@ -124,9 +124,7 @@ export class Binding {
     updating = false;
     source: WeakRef<Object>;
     target: WeakRef<Bindable>;
-    weakEventListenerOptions: weakEventListener.WeakEventListenerOptions;
-
-    weakEL = weakEventListener.WeakEventListener;
+    weakEventId: number;
 
     private sourceOptions: { instance: WeakRef<any>; property: any };
     private targetOptions: { instance: WeakRef<any>; property: any };
@@ -145,11 +143,11 @@ export class Binding {
         if (typeof (obj) === "number") {
             obj = new Number(obj);
         }
-        
+
         if (typeof (obj) === "boolean") {
             obj = new Boolean(obj);
         }
-        
+
         if (typeof (obj) === "string") {
             obj = new String(obj);
         }
@@ -164,15 +162,12 @@ export class Binding {
         if (this.sourceOptions) {
             var sourceOptionsInstance = this.sourceOptions.instance.get();
             if (sourceOptionsInstance instanceof observable.Observable) {
-                this.weakEventListenerOptions = {
-                    targetWeakRef: this.target,
-                    sourceWeakRef: this.sourceOptions.instance,
+                this.weakEventId = weakEvents.WeakEventListener.addWeakEventListener({
+                    target: this,
+                    source: this.sourceOptions.instance.get(),
                     eventName: observable.Observable.propertyChangeEvent,
                     handler: this.onSourcePropertyChanged,
-                    handlerContext: this,
-                    key: this.options.targetProperty
-                }
-                this.weakEL.addWeakEventListener(this.weakEventListenerOptions);
+                });
             }
         }
     }
@@ -182,24 +177,25 @@ export class Binding {
             return;
         }
 
-        this.weakEL.removeWeakEventListener(this.weakEventListenerOptions);
-        this.weakEventListenerOptions = undefined;
-		if (this.source) {
-			this.source.clear();
-		}
-		if (this.sourceOptions) {
-			this.sourceOptions.instance.clear();
-			this.sourceOptions = undefined;
-		}
-		if (this.targetOptions) {
-			this.targetOptions = undefined;
-		}
+        weakEvents.WeakEventListener.removeWeakEventListener(this.weakEventId);
+        delete this.weakEventId;
+
+        if (this.source) {
+            this.source.clear();
+        }
+        if (this.sourceOptions) {
+            this.sourceOptions.instance.clear();
+            this.sourceOptions = undefined;
+        }
+        if (this.targetOptions) {
+            this.targetOptions = undefined;
+        }
     }
 
     public updateTwoWay(value: any) {
-		if (this.updating) {
-			return;
-		}
+        if (this.updating) {
+            return;
+        }
         if (this.options.twoWay) {
             if (this._isExpression(this.options.expression)) {
                 var changedModel = {};
@@ -238,15 +234,15 @@ export class Binding {
             var exp = polymerExpressions.PolymerExpressions.getExpression(expression);
             if (exp) {
                 var context = this.source && this.source.get && this.source.get() || global;
-				var model = {};
-				model[contextKey] = context;
-				model[resourcesKey] = appModule.resources;
-				return exp.getValue(model, isBackConvert, changedModel);
+                var model = {};
+                model[contextKey] = context;
+                model[resourcesKey] = appModule.resources;
+                return exp.getValue(model, isBackConvert, changedModel);
             }
             return new Error(expression + " is not a valid expression.");
         }
         catch (e) {
-            var errorMessage = "Run-time error occured in file: " + e.sourceURL + " at line: " + e.line + " and column: " + e.column; 
+            var errorMessage = "Run-time error occured in file: " + e.sourceURL + " at line: " + e.line + " and column: " + e.column;
             return new Error(errorMessage);
         }
     }
@@ -293,7 +289,7 @@ export class Binding {
             }
             else if (sourceOptionsInstance instanceof observable.Observable) {
                 value = sourceOptionsInstance.get(this.sourceOptions.property);
-            } 
+            }
             else if (sourceOptionsInstance && this.sourceOptions.property &&
                 this.sourceOptions.property in sourceOptionsInstance) {
                 value = sourceOptionsInstance[this.sourceOptions.property];
diff --git a/ui/core/weak-event-listener.d.ts b/ui/core/weak-event-listener.d.ts
index 1637a062b..7424e850c 100644
--- a/ui/core/weak-event-listener.d.ts
+++ b/ui/core/weak-event-listener.d.ts
@@ -8,12 +8,12 @@ declare module "ui/core/weak-event-listener" {
         /**
          * Weak reference to the subscriber (target) of the event listener.
          */
-        targetWeakRef: WeakRef<any>;
+        target: any;
 
         /**
-         * Weak reference to an instance of observable.Observable class which emits the event.
+         * Weak reference to an instance of observable. Observable class which emits the event.
          */
-        sourceWeakRef: WeakRef<observable.Observable>;
+        source: observable.Observable;
 
         /**
          * Name of the event.
@@ -24,16 +24,6 @@ declare module "ui/core/weak-event-listener" {
          * The function which should be called when event occurs.
          */
         handler: (eventData: observable.EventData) => void;
-
-        /**
-         * The context (thisArg) in which handler should be executed.
-         */
-        handlerContext?: any;
-
-        /**
-         * A string to use as key for key value pair instance.
-         */
-        key: string;
     }
 
     /**
@@ -43,14 +33,26 @@ declare module "ui/core/weak-event-listener" {
         /**
          * Creates and initialize WeakEventListener (if all required options are set).
          * @param options An instance of WeakEventListenerOptions needed to create WeakEventListener instance.
-         * Returns true if a WeakEventListener instance is created successfully.
+         * Returns The id of the WeakEventListener object to be used in removeWeakEventListener method.
          */
-        static addWeakEventListener(options: WeakEventListenerOptions): boolean;
+        static addWeakEventListener(options: WeakEventListenerOptions): number;
 
         /**
          * Removes and clears all resources from WeakEventListener.
-         * @param options An instance of WeakEventListenerOptions used to create the WeakEventListener instance.
+         * @param The id of the WeakEventListener object.
          */
-        static removeWeakEventListener(options: WeakEventListenerOptions): void;
+        static removeWeakEventListener(listenerId: number): void;
+
+        /** 
+         * Specifies how often will internal clearing of dead references will occur. 
+         * Clearing will be triggered on addWeakEventListener on every N times where N is
+         * the value of this property. Set 0 to disable clearing.
+         */
+        static cleanDeadReferencesCountTrigger: number;
+
+        //@private
+        static _cleanDeadReferences();
+        static _weakEventListeners: Object;
+        //@endprivate
     }
 }
\ No newline at end of file
diff --git a/ui/core/weak-event-listener.ts b/ui/core/weak-event-listener.ts
index 543673cc6..2bf5def4a 100644
--- a/ui/core/weak-event-listener.ts
+++ b/ui/core/weak-event-listener.ts
@@ -1,103 +1,121 @@
 import observable = require("data/observable");
 import definition = require("ui/core/weak-event-listener");
+import types = require("utils/types");
 
+var CLEAN_TRIGGER_DEFAULT = 1000;
 export class WeakEventListener implements definition.WeakEventListener {
-    private listener: WeakRef<any>;
-    private sender: WeakRef<observable.Observable>;
+    private id: number;
+    private targetRef: WeakRef<any>;
+    private senderRef: WeakRef<observable.Observable>;
     private eventName: string;
     private handler: (eventData: observable.EventData) => void;
-    private handlerContext: any;
 
-    static rootWeakEventListenersMap = new WeakMap();
+    static _idCounter: number = 0;
+    static _weakEventListeners = {};
+    static _cleanDeadReferencesCountTrigger = CLEAN_TRIGGER_DEFAULT;
+    static get cleanDeadReferencesCountTrigger(): number {
+        return WeakEventListener._cleanDeadReferencesCountTrigger;
+    }
+    static set cleanDeadReferencesCountTrigger(value: number) {
+        WeakEventListener._cleanDeadReferencesCountTrigger = value;
+    }
 
     private handlerCallback(eventData) {
-        if (this.handler) {
-            if (this.handlerContext) {
-                this.handler.call(this.handlerContext, eventData);
-            }
-            else {
-                this.handler(eventData);
-            }
+        var target = this.targetRef.get();
+        if (target) {
+            this.handler.call(target, eventData);
+        }
+        else {
+            // The target is dead - we can unsubscribe;
+            WeakEventListener.removeWeakEventListener(this.id);
         }
     }
 
-    private init(options: definition.WeakEventListenerOptions) {
-        this.listener = options.targetWeakRef;
-        this.sender = options.sourceWeakRef;
+    private init(options: definition.WeakEventListenerOptions, listenerId: number) {
+        this.id = listenerId;
+        this.targetRef = new WeakRef(options.target);
+        this.senderRef = new WeakRef(options.source);
         this.eventName = options.eventName;
         this.handler = options.handler;
-        if (options.handlerContext) {
-            this.handlerContext = options.handlerContext;
-        }
-        var sourceInstance = this.sender.get();
+
+        var sourceInstance = this.senderRef.get();
         if (sourceInstance) {
             sourceInstance.addEventListener(this.eventName, this.handlerCallback, this);
         }
     }
 
-    static addWeakEventListener(options: definition.WeakEventListenerOptions) {
-        if (options.targetWeakRef && options.sourceWeakRef && options.eventName && options.handler && options.key) {
-            var weakEventListener = new WeakEventListener();
-            weakEventListener.init(options);
-            var targetWeakEventListenersMap = WeakEventListener.getWeakMapValueByKeys([options.sourceWeakRef, options.targetWeakRef]);
-            targetWeakEventListenersMap[options.key] = weakEventListener;
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-
     private clear() {
-        var sourceInstance = this.sender.get();
-        if (sourceInstance) {
-            sourceInstance.removeEventListener(this.eventName, this.handlerCallback, this);
-            this.sender.clear();
+        var sender = this.senderRef.get();
+        if (sender) {
+            sender.removeEventListener(this.eventName, this.handlerCallback, this);
         }
-        this.listener = undefined;
+
+        this.targetRef.clear();
+        this.targetRef = undefined;
+        this.senderRef.clear();
+        this.senderRef = undefined;
+
         this.eventName = undefined;
         this.handler = undefined;
-        this.handlerContext = undefined;
     }
 
-    static getWeakMapValueByKeys(keys) {
-        var result;
-        if (!WeakEventListener.rootWeakEventListenersMap) {
-            WeakEventListener.rootWeakEventListenersMap = new WeakMap();
+    static addWeakEventListener(options: definition.WeakEventListenerOptions) {
+        if (types.isNullOrUndefined(options.target)) {
+            throw new Error("targetWeakRef is null or undefined");
         }
-        var currentMap = WeakEventListener.rootWeakEventListenersMap;
-        var i;
-        for (i = 0; i < keys.length - 1; i++) {
-            if (currentMap.has(keys[i])) {
-                currentMap = <WeakMap<{}, {}>>currentMap.get(keys[i]);
-            }
-            else {
-                var innerMap = new WeakMap();
-                currentMap.set(keys[i], innerMap);
-                currentMap = innerMap;
+
+        if (types.isNullOrUndefined(options.source)) {
+            throw new Error("sourceWeakRef is null or undefined");
+        }
+
+        if (!types.isString(options.eventName)) {
+            throw new Error("eventName is not a string");
+        }
+
+        if (!types.isFunction(options.handler)) {
+            throw new Error("handler is not a function");
+        }
+
+        var listenerId = WeakEventListener._idCounter++;
+        var weakEventListener = new WeakEventListener();
+        weakEventListener.init(options, listenerId);
+
+        WeakEventListener._weakEventListeners[listenerId] = new WeakRef(weakEventListener);
+
+        if (WeakEventListener._cleanDeadReferencesCountTrigger &&
+            (listenerId % WeakEventListener._cleanDeadReferencesCountTrigger) === 0) {
+            WeakEventListener._cleanDeadReferences();
+        }
+
+        return listenerId;
+    }
+
+    static removeWeakEventListener(listenerId: number) {
+        var listenerRef = <WeakRef<WeakEventListener>>WeakEventListener._weakEventListeners[listenerId];
+
+        if (listenerRef) {
+            var listener = <WeakEventListener>listenerRef.get();
+            if (listener) {
+                listener.clear();
             }
         }
 
-        if (currentMap.has(keys[keys.length - 1])) {
-            result = currentMap.get(keys[keys.length - 1]);
-        }
-
-        if (!result) {
-            result = {};
-            currentMap.set(keys[keys.length - 1], result);
-        }
-        return result;
+        delete WeakEventListener._weakEventListeners[listenerId];
     }
 
-    static removeWeakEventListener(options: definition.WeakEventListenerOptions) {
-        if (options && options.sourceWeakRef && options.targetWeakRef && options.key) {
-            var weakMapValueForKey = WeakEventListener.getWeakMapValueByKeys([options.sourceWeakRef, options.targetWeakRef]);
-            if (weakMapValueForKey && weakMapValueForKey[options.key]) {
-                if (weakMapValueForKey[options.key] instanceof definition.WeakEventListener) {
-                    (<WeakEventListener>weakMapValueForKey[options.key]).clear();
-                }
-                delete weakMapValueForKey[options.key];
+    static _cleanDeadReferences() {
+        var deadListeners = new Array<number>();
+        for (var id in WeakEventListener._weakEventListeners) {
+            var listenerRef = <WeakRef<WeakEventListener>>WeakEventListener._weakEventListeners[id];
+
+            var listener = listenerRef.get();
+            if (!listener || !listener.targetRef.get() || !listener.senderRef.get()) {
+                deadListeners.push(id);
             }
         }
+
+        for (var i = 0; i < deadListeners.length; i++) {
+            WeakEventListener.removeWeakEventListener(deadListeners[i]);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/ui/list-view/list-view-common.ts b/ui/list-view/list-view-common.ts
index 5d36a53b7..a5cc1ece5 100644
--- a/ui/list-view/list-view-common.ts
+++ b/ui/list-view/list-view-common.ts
@@ -8,13 +8,13 @@ import builder = require("ui/builder");
 import label = require("ui/label");
 import color = require("color");
 import weakEventListener = require("ui/core/weak-event-listener");
+import types = require("utils/types");
 
 var ITEMS = "items";
 var ITEMTEMPLATE = "itemTemplate";
 var ISSCROLLING = "isScrolling";
 var LISTVIEW = "ListView";
 var SEPARATORCOLOR = "separatorColor";
-var WEAKEVENTKEY = "_observableArrayChanged";
 
 export module knownTemplates {
     export var itemTemplate = "itemTemplate";
@@ -69,13 +69,7 @@ export class ListView extends view.View implements definition.ListView {
             )
         );
 
-    private _itemsChanged: (args: observable.EventData) => void;
-    private _weakEventListenerOptions: weakEventListener.WeakEventListenerOptions;
-
-    constructor() {
-        super();
-        this._itemsChanged = (args: observable.EventData) => { this.refresh(); };
-    }
+    private _itemsChangedWeakListenerId: number;
 
     get items(): any {
         return this._getValue(ListView.itemsProperty);
@@ -136,27 +130,27 @@ export class ListView extends view.View implements definition.ListView {
         return lbl;
     }
 
-
     public _onItemsPropertyChanged(data: dependencyObservable.PropertyChangeData) {
-        if (data.oldValue instanceof observable.Observable && this._weakEventListenerOptions) {
-            weakEventListener.WeakEventListener.removeWeakEventListener(this._weakEventListenerOptions);
-            this._weakEventListenerOptions = null;
+        if (data.oldValue instanceof observable.Observable && types.isDefined(this._itemsChangedWeakListenerId)) {
+            weakEventListener.WeakEventListener.removeWeakEventListener(this._itemsChangedWeakListenerId);
+            delete this._itemsChangedWeakListenerId;
         }
 
         if (data.newValue instanceof observable.Observable) {
-            this._weakEventListenerOptions = {
-                targetWeakRef: new WeakRef(this),
-                sourceWeakRef: new WeakRef(data.newValue),
+            this._itemsChangedWeakListenerId = weakEventListener.WeakEventListener.addWeakEventListener({
+                target: this,
+                source: data.newValue,
                 eventName: observableArray.ObservableArray.changeEvent,
-                handler: this._itemsChanged,
-                handlerContext: this,
-                key: WEAKEVENTKEY
-            };
-            weakEventListener.WeakEventListener.addWeakEventListener(this._weakEventListenerOptions);
+                handler: this._onItemsChanged,
+            });
         }
 
         this.refresh();
     }
+
+    private _onItemsChanged(args: observable.EventData) {
+        this.refresh();
+    }
 }
 
 function getExports(instance: view.View): any {
diff --git a/ui/text-base/text-base.ts b/ui/text-base/text-base.ts
index 92ab9a124..1bf124d7f 100644
--- a/ui/text-base/text-base.ts
+++ b/ui/text-base/text-base.ts
@@ -38,6 +38,8 @@ export class TextBase extends view.View implements definition.TextBase {
     public static textProperty = textProperty;
     public static formattedTextProperty = formattedTextProperty;
 
+    private _formattedTextChangedListenerId: number;
+
     constructor(options?: definition.Options) {
         super(options);
     }
@@ -77,20 +79,18 @@ export class TextBase extends view.View implements definition.TextBase {
 
     set formattedText(value: formattedString.FormattedString) {
         if (this.formattedText !== value) {
-            var weakEventOptions: weakEventListener.WeakEventListenerOptions = {
-                targetWeakRef: new WeakRef(this),
-                eventName: observable.Observable.propertyChangeEvent,
-                sourceWeakRef: new WeakRef(value),
-                handler: this.onFormattedTextChanged,
-                handlerContext: this,
-                key: "formattedText"
-            };
             if (this.formattedText) {
-                weakEventListener.WeakEventListener.removeWeakEventListener(weakEventOptions);
+                weakEventListener.WeakEventListener.removeWeakEventListener(this._formattedTextChangedListenerId);
+                delete this._formattedTextChangedListenerId;
             }
             this._setValue(TextBase.formattedTextProperty, value);
             if (value) {
-                weakEventListener.WeakEventListener.addWeakEventListener(weakEventOptions);
+                this._formattedTextChangedListenerId = weakEventListener.WeakEventListener.addWeakEventListener({
+                    target: this,
+                    source: value,
+                    eventName: observable.Observable.propertyChangeEvent,
+                    handler: this.onFormattedTextChanged,
+                });
             }
         }
     }

From 54f6c350dee09ed3a97d0e92ca60c48122442fcf Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Thu, 14 May 2015 13:49:03 +0300
Subject: [PATCH 4/9] Cean up

---
 ui/core/weak-event-listener.d.ts | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/ui/core/weak-event-listener.d.ts b/ui/core/weak-event-listener.d.ts
index 7424e850c..a1fd306c6 100644
--- a/ui/core/weak-event-listener.d.ts
+++ b/ui/core/weak-event-listener.d.ts
@@ -6,12 +6,12 @@ declare module "ui/core/weak-event-listener" {
      */
     export interface WeakEventListenerOptions {
         /**
-         * Weak reference to the subscriber (target) of the event listener.
+         * Subscriber (target) of the event listener. It will be used as a thisArg in the handler function.
          */
         target: any;
 
         /**
-         * Weak reference to an instance of observable. Observable class which emits the event.
+         * Observable class which emits the event.
          */
         source: observable.Observable;
 
@@ -38,7 +38,7 @@ declare module "ui/core/weak-event-listener" {
         static addWeakEventListener(options: WeakEventListenerOptions): number;
 
         /**
-         * Removes and clears all resources from WeakEventListener.
+         * Removes and clears all resources from WeakEventListener with given id.
          * @param The id of the WeakEventListener object.
          */
         static removeWeakEventListener(listenerId: number): void;
@@ -51,7 +51,6 @@ declare module "ui/core/weak-event-listener" {
         static cleanDeadReferencesCountTrigger: number;
 
         //@private
-        static _cleanDeadReferences();
         static _weakEventListeners: Object;
         //@endprivate
     }

From 57171c768e864eeafa37e11b594397245bc33fb9 Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Fri, 15 May 2015 16:55:02 +0300
Subject: [PATCH 5/9] WeakEvents with map

---
 apps/tests/ui/helper.ts                 |   1 +
 apps/tests/weak-event-listener-tests.ts | 202 +++++++++------------
 ui/button/button-common.ts              |  13 +-
 ui/core/bindable.ts                     |  22 ++-
 ui/core/weak-event-listener.d.ts        |  60 ++-----
 ui/core/weak-event-listener.ts          | 230 +++++++++++++-----------
 ui/list-view/list-view-common.ts        |  11 +-
 ui/text-base/text-base.ts               |  14 +-
 8 files changed, 251 insertions(+), 302 deletions(-)

diff --git a/apps/tests/ui/helper.ts b/apps/tests/ui/helper.ts
index b2ad8b48e..ef59eb584 100644
--- a/apps/tests/ui/helper.ts
+++ b/apps/tests/ui/helper.ts
@@ -225,6 +225,7 @@ export function forceGC() {
     if (platform.device.os === platform.platformNames.ios) {
         // Could cause GC on the next call.
         new ArrayBuffer(4 * 1024 * 1024);
+        TKUnit.wait(ASYNC);
     }
     utils.GC();
 }
\ No newline at end of file
diff --git a/apps/tests/weak-event-listener-tests.ts b/apps/tests/weak-event-listener-tests.ts
index 96eb01f34..49524f1a0 100644
--- a/apps/tests/weak-event-listener-tests.ts
+++ b/apps/tests/weak-event-listener-tests.ts
@@ -4,89 +4,64 @@ import observable = require("data/observable");
 import weakEvents = require("ui/core/weak-event-listener");
 import helper = require("./ui/helper");
 
+class Target {
+    public counter: number = 0;
+    public onEvent(data: observable.EventData) {
+        this.counter++;
+    }
+
+}
+
 export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_source() {
     TKUnit.assertThrows(() => {
-        weakEvents.WeakEventListener.addWeakEventListener({
-            source: undefined,
-            target: {},
-            handler: emptyHandler,
-            eventName: observable.Observable.propertyChangeEvent
-        });
+        weakEvents.addWeakEventListener(undefined, "eventName", emptyHandler, {});
     });
 }
 
 export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_target() {
     TKUnit.assertThrows(() => {
-        weakEvents.WeakEventListener.addWeakEventListener({
-            source: new observable.Observable(),
-            target: undefined,
-            handler: emptyHandler,
-            eventName: observable.Observable.propertyChangeEvent
-        });
+        weakEvents.addWeakEventListener(new observable.Observable(), "eventName", emptyHandler, undefined);
     });
 }
 
 export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_handler() {
     TKUnit.assertThrows(() => {
-        weakEvents.WeakEventListener.addWeakEventListener({
-            source: new observable.Observable(),
-            target: {},
-            handler: undefined,
-            eventName: observable.Observable.propertyChangeEvent
-        });
+        weakEvents.addWeakEventListener(new observable.Observable(), "eventName", undefined, {});
     });
 }
 
 export function test_addWeakEventListener_throwsWhenCalledwitnInvalid_name() {
     TKUnit.assertThrows(() => {
-        weakEvents.WeakEventListener.addWeakEventListener({
-            source: new observable.Observable(),
-            target: {},
-            handler: emptyHandler,
-            eventName: undefined
-        });
+        weakEvents.addWeakEventListener(new observable.Observable(), undefined, emptyHandler, {});
     });
 }
 
 export function test_addWeakEventListener_listensForEvent() {
     var source = new observable.Observable();
-    var target = new Object;
-    var callbackCalled = false;
-    var handler = function (args: observable.EventData) {
-        callbackCalled = true;
-    }
+    var target = new Target();
 
-    weakEvents.WeakEventListener.addWeakEventListener({
-        source: source,
-        target: target,
-        handler: handler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
+    weakEvents.addWeakEventListener(
+        source,
+        observable.Observable.propertyChangeEvent,
+        target.onEvent,
+        target);
+
+    helper.forceGC();
 
     source.set("testProp", "some value");
 
-    TKUnit.assert(callbackCalled, "Handler not called.");
+    TKUnit.assertEqual(target.counter, 1, "Handler not called.");
 }
 
 export function test_removeWeakEventListener_StopsListeningForEvet() {
     var source = new observable.Observable();
-    var target = new Object;
-    var callbackCalled = false;
-    var handler = function (args: observable.EventData) {
-        callbackCalled = true;
-    }
+    var target = new Target();
 
-    var listenerID = weakEvents.WeakEventListener.addWeakEventListener({
-        source: source,
-        target: target,
-        handler: handler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
-
-    weakEvents.WeakEventListener.removeWeakEventListener(listenerID);
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target);
+    weakEvents.removeWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target)
 
     source.set("testProp", "some value");
-    TKUnit.assert(!callbackCalled, "Handler should not be called.");
+    TKUnit.assertEqual(target.counter, 0, "Handler should not be called.");
 }
 
 export function test_handlerIsCalled_WithTargetAsThis() {
@@ -98,12 +73,7 @@ export function test_handlerIsCalled_WithTargetAsThis() {
         callbackCalled = true;
     }
 
-    weakEvents.WeakEventListener.addWeakEventListener({
-        source: source,
-        target: target,
-        handler: handler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, handler, target);
 
     source.set("testProp", "some value");
     TKUnit.assert(callbackCalled, "Handler not called.");
@@ -111,19 +81,10 @@ export function test_handlerIsCalled_WithTargetAsThis() {
 
 export function test_listnerDoesNotRetainTarget() {
     var source = new observable.Observable();
-    var target = new Object;
+    var target = new Target();
     var callbackCalled = false;
-    var handler = function (args: observable.EventData) {
-        TKUnit.assertEqual(this, target, "this should be the target");
-        callbackCalled = true;
-    }
 
-    weakEvents.WeakEventListener.addWeakEventListener({
-        source: source,
-        target: target,
-        handler: handler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target);
 
     var targetRef = new WeakRef(target);
     target = undefined;
@@ -134,19 +95,10 @@ export function test_listnerDoesNotRetainTarget() {
 
 export function test_listnerDoesNotRetainSource() {
     var source = new observable.Observable();
-    var target = new Object();
+    var target = new Target();
     var callbackCalled = false;
-    var handler = function (args: observable.EventData) {
-        TKUnit.assertEqual(this, target, "this should be the target");
-        callbackCalled = true;
-    }
 
-    weakEvents.WeakEventListener.addWeakEventListener({
-        source: source,
-        target: target,
-        handler: handler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target);
 
     var sourceRef = new WeakRef(source);
     source = undefined;
@@ -155,50 +107,74 @@ export function test_listnerDoesNotRetainSource() {
     TKUnit.assert(!sourceRef.get(), "Source should be released after GC");
 }
 
-export function test_listnerIsCleared_WhenTargetIsDead() {
-    var source = new observable.Observable();
+//export function test_listnerIsCleared_WhenTargetIsDead() {
+//    var source = new observable.Observable();
 
-    var listenerID = addListenerWithSource(source);
-    helper.forceGC();
+//    var listenerID = addListenerWithSource(source);
+//    helper.forceGC();
 
-    for (var i = 0; i < weakEvents.WeakEventListener.cleanDeadReferencesCountTrigger; i++) {
-        addListenerWithSource(source);
-    }
+//    for (var i = 0; i < weakEvents.cleanDeadReferencesCountTrigger; i++) {
+//        addListenerWithSource(source);
+//    }
 
-    TKUnit.assert(types.isUndefined(weakEvents.WeakEventListener._weakEventListeners[listenerID]), "The first listener should be dead by now");
-}
+//    TKUnit.assert(types.isUndefined(weakEvents._weakEventListeners[listenerID]), "The first listener should be dead by now");
+//}
 
-export function test_listnerIsCleared_WhenSourceIsDead() {
-    var target = {};
+//export function test_listnerIsCleared_WhenSourceIsDead() {
+//    var target = {};
 
-    var listenerID = addListenerWithTarget(target);
-    helper.forceGC();
+//    var listenerID = addListenerWithTarget(target);
+//    helper.forceGC();
 
-    for (var i = 0; i < weakEvents.WeakEventListener.cleanDeadReferencesCountTrigger; i++) {
-        addListenerWithTarget(target);
-    }
+//    for (var i = 0; i < weakEvents.cleanDeadReferencesCountTrigger; i++) {
+//        addListenerWithTarget(target);
+//    }
 
-    TKUnit.assert(types.isUndefined(weakEvents.WeakEventListener._weakEventListeners[listenerID]), "The first listener should be dead by now");
-}
+//    TKUnit.assert(types.isUndefined(weakEvents._weakEventListeners[listenerID]), "The first listener should be dead by now");
+//}
 
-function addListenerWithSource(source: observable.Observable): number {
-    return weakEvents.WeakEventListener.addWeakEventListener({
-        source: source,
-        target: {},
-        handler: emptyHandler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
-}
+//function addListenerWithSource(source: observable.Observable): number {
+//    return weakEvents.addWeakEventListener({
+//        source: source,
+//        target: {},
+//        handler: emptyHandler,
+//        eventName: observable.Observable.propertyChangeEvent
+//    })
+//}
 
-function addListenerWithTarget(target: any): number {
-    return weakEvents.WeakEventListener.addWeakEventListener({
-        source: new observable.Observable(),
-        target: target,
-        handler: emptyHandler,
-        eventName: observable.Observable.propertyChangeEvent
-    })
-}
+//function addListenerWithTarget(target: any): number {
+//    return weakEvents.addWeakEventListener({
+//        source: new observable.Observable(),
+//        target: target,
+//        handler: emptyHandler,
+//        eventName: observable.Observable.propertyChangeEvent
+//    })
+//}
 
 function emptyHandler(data: observable.EventData) {
     // Do nothing.
-}
\ No newline at end of file
+}
+
+
+
+export function testWeakMap(): void {
+    var source = new observable.Observable();
+    var target = new Target();
+    var targetRef = new WeakRef(target);
+    var weakMap = new WeakMap<observable.Observable, Target>();
+
+    weakMap.set(source, target);
+    TKUnit.assertEqual(weakMap.get(source), target, "target");
+
+    target = undefined;
+    source = undefined;
+
+    helper.forceGC();
+    TKUnit.wait(1);
+
+    TKUnit.waitUntilReady(function () {
+        return false;
+    })
+
+    TKUnit.assert(!targetRef.get(), "Target should be dead");
+}
diff --git a/ui/button/button-common.ts b/ui/button/button-common.ts
index e1d8cfdc6..47922c008 100644
--- a/ui/button/button-common.ts
+++ b/ui/button/button-common.ts
@@ -4,7 +4,7 @@ import definition = require("ui/button");
 import proxy = require("ui/core/proxy");
 import formattedString = require("text/formatted-string");
 import observable = require("data/observable");
-import weakEventListener = require("ui/core/weak-event-listener");
+import weakEvents = require("ui/core/weak-event-listener");
 
 var textProperty = new dependencyObservable.Property(
     "text",
@@ -37,8 +37,6 @@ export class Button extends view.View implements definition.Button {
     public static textProperty = textProperty;
     public static formattedTextProperty = formattedTextProperty;
 
-    private _formattedTextWeakListenerId: number;
-
     public _onBindingContextChanged(oldValue: any, newValue: any) {
         super._onBindingContextChanged(oldValue, newValue);
         if (this.formattedText) {
@@ -61,16 +59,11 @@ export class Button extends view.View implements definition.Button {
     set formattedText(value: formattedString.FormattedString) {
         if (this.formattedText !== value) {
             if (this.formattedText) {
-                weakEventListener.WeakEventListener.removeWeakEventListener(this._formattedTextWeakListenerId);
+                weakEvents.removeWeakEventListener(this.formattedText, observable.Observable.propertyChangeEvent, this.onFormattedTextChanged, this);
             }
             this._setValue(Button.formattedTextProperty, value);
             if (value) {
-                this._formattedTextWeakListenerId = weakEventListener.WeakEventListener.addWeakEventListener({
-                    target: this,
-                    source: value,
-                    eventName: observable.Observable.propertyChangeEvent,
-                    handler: this.onFormattedTextChanged
-                });
+                weakEvents.addWeakEventListener(value, observable.Observable.propertyChangeEvent, this.onFormattedTextChanged, this);
             }
         }
     }
diff --git a/ui/core/bindable.ts b/ui/core/bindable.ts
index 09e728877..da860ac59 100644
--- a/ui/core/bindable.ts
+++ b/ui/core/bindable.ts
@@ -162,12 +162,11 @@ export class Binding {
         if (this.sourceOptions) {
             var sourceOptionsInstance = this.sourceOptions.instance.get();
             if (sourceOptionsInstance instanceof observable.Observable) {
-                this.weakEventId = weakEvents.WeakEventListener.addWeakEventListener({
-                    target: this,
-                    source: this.sourceOptions.instance.get(),
-                    eventName: observable.Observable.propertyChangeEvent,
-                    handler: this.onSourcePropertyChanged,
-                });
+                weakEvents.addWeakEventListener(
+                    sourceOptionsInstance,
+                    observable.Observable.propertyChangeEvent,
+                    this.onSourcePropertyChanged,
+                    this);
             }
         }
     }
@@ -177,8 +176,15 @@ export class Binding {
             return;
         }
 
-        weakEvents.WeakEventListener.removeWeakEventListener(this.weakEventId);
-        delete this.weakEventId;
+        if (this.sourceOptions) {
+            var sourceOptionsInstance = this.sourceOptions.instance.get();
+            if (sourceOptionsInstance) {
+                weakEvents.removeWeakEventListener(sourceOptionsInstance,
+                    observable.Observable.propertyChangeEvent,
+                    this.onSourcePropertyChanged,
+                    this);
+            }
+        }
 
         if (this.source) {
             this.source.clear();
diff --git a/ui/core/weak-event-listener.d.ts b/ui/core/weak-event-listener.d.ts
index a1fd306c6..450f04981 100644
--- a/ui/core/weak-event-listener.d.ts
+++ b/ui/core/weak-event-listener.d.ts
@@ -2,56 +2,20 @@ declare module "ui/core/weak-event-listener" {
     import observable = require("data/observable");
 
     /**
-     * An interface that defines all options needed for creating weak event listener.
+     * Creates and initialize WeakEventListener.
+     * @param source Observable class which emits the event.
+     * @param eventName The event name.
+     * @param handler The function which should be called when event occurs.
+     * @param target Subscriber (target) of the event listener. It will be used as a thisArg in the handler function.
      */
-    export interface WeakEventListenerOptions {
-        /**
-         * Subscriber (target) of the event listener. It will be used as a thisArg in the handler function.
-         */
-        target: any;
-
-        /**
-         * Observable class which emits the event.
-         */
-        source: observable.Observable;
-
-        /**
-         * Name of the event.
-         */
-        eventName: string;
-
-        /**
-         * The function which should be called when event occurs.
-         */
-        handler: (eventData: observable.EventData) => void;
-    }
+    export function addWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) : void;
 
     /**
-     * Represents a class that utilize work with weak event listeners.
+     * Removes and clears all resources from WeakEventListener.
+     * @param source Observable class which emits the event.
+     * @param eventName The event name.
+     * @param handler The function which should be called when event occurs.
+     * @param target Subscriber (target) of the event listener. It will be used as a thisArg in the handler function.
      */
-    export class WeakEventListener {
-        /**
-         * Creates and initialize WeakEventListener (if all required options are set).
-         * @param options An instance of WeakEventListenerOptions needed to create WeakEventListener instance.
-         * Returns The id of the WeakEventListener object to be used in removeWeakEventListener method.
-         */
-        static addWeakEventListener(options: WeakEventListenerOptions): number;
-
-        /**
-         * Removes and clears all resources from WeakEventListener with given id.
-         * @param The id of the WeakEventListener object.
-         */
-        static removeWeakEventListener(listenerId: number): void;
-
-        /** 
-         * Specifies how often will internal clearing of dead references will occur. 
-         * Clearing will be triggered on addWeakEventListener on every N times where N is
-         * the value of this property. Set 0 to disable clearing.
-         */
-        static cleanDeadReferencesCountTrigger: number;
-
-        //@private
-        static _weakEventListeners: Object;
-        //@endprivate
-    }
+    export function removeWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any): void;
 }
\ No newline at end of file
diff --git a/ui/core/weak-event-listener.ts b/ui/core/weak-event-listener.ts
index 2bf5def4a..886125964 100644
--- a/ui/core/weak-event-listener.ts
+++ b/ui/core/weak-event-listener.ts
@@ -2,120 +2,142 @@
 import definition = require("ui/core/weak-event-listener");
 import types = require("utils/types");
 
-var CLEAN_TRIGGER_DEFAULT = 1000;
-export class WeakEventListener implements definition.WeakEventListener {
-    private id: number;
-    private targetRef: WeakRef<any>;
-    private senderRef: WeakRef<observable.Observable>;
-    private eventName: string;
-    private handler: (eventData: observable.EventData) => void;
+var handlersForEventName = new Map<string,(eventData: observable.EventData) => void>();
+var sourcesMap = new WeakMap<observable.Observable, Map<string, Array<TargetHandlerPair>>>();
 
-    static _idCounter: number = 0;
-    static _weakEventListeners = {};
-    static _cleanDeadReferencesCountTrigger = CLEAN_TRIGGER_DEFAULT;
-    static get cleanDeadReferencesCountTrigger(): number {
-        return WeakEventListener._cleanDeadReferencesCountTrigger;
-    }
-    static set cleanDeadReferencesCountTrigger(value: number) {
-        WeakEventListener._cleanDeadReferencesCountTrigger = value;
+class TargetHandlerPair {
+    tagetRef: WeakRef<Object>;
+    handler: (eventData: observable.EventData) => void;
+
+    constructor(target: Object, handler: (eventData: observable.EventData) => void) {
+        this.tagetRef = new WeakRef(target);
+        this.handler = handler;
     }
+}
 
-    private handlerCallback(eventData) {
-        var target = this.targetRef.get();
-        if (target) {
-            this.handler.call(target, eventData);
-        }
-        else {
-            // The target is dead - we can unsubscribe;
-            WeakEventListener.removeWeakEventListener(this.id);
-        }
-    }
-
-    private init(options: definition.WeakEventListenerOptions, listenerId: number) {
-        this.id = listenerId;
-        this.targetRef = new WeakRef(options.target);
-        this.senderRef = new WeakRef(options.source);
-        this.eventName = options.eventName;
-        this.handler = options.handler;
-
-        var sourceInstance = this.senderRef.get();
-        if (sourceInstance) {
-            sourceInstance.addEventListener(this.eventName, this.handlerCallback, this);
-        }
-    }
-
-    private clear() {
-        var sender = this.senderRef.get();
-        if (sender) {
-            sender.removeEventListener(this.eventName, this.handlerCallback, this);
-        }
-
-        this.targetRef.clear();
-        this.targetRef = undefined;
-        this.senderRef.clear();
-        this.senderRef = undefined;
-
-        this.eventName = undefined;
-        this.handler = undefined;
-    }
-
-    static addWeakEventListener(options: definition.WeakEventListenerOptions) {
-        if (types.isNullOrUndefined(options.target)) {
-            throw new Error("targetWeakRef is null or undefined");
-        }
-
-        if (types.isNullOrUndefined(options.source)) {
-            throw new Error("sourceWeakRef is null or undefined");
-        }
-
-        if (!types.isString(options.eventName)) {
-            throw new Error("eventName is not a string");
-        }
-
-        if (!types.isFunction(options.handler)) {
-            throw new Error("handler is not a function");
-        }
-
-        var listenerId = WeakEventListener._idCounter++;
-        var weakEventListener = new WeakEventListener();
-        weakEventListener.init(options, listenerId);
-
-        WeakEventListener._weakEventListeners[listenerId] = new WeakRef(weakEventListener);
-
-        if (WeakEventListener._cleanDeadReferencesCountTrigger &&
-            (listenerId % WeakEventListener._cleanDeadReferencesCountTrigger) === 0) {
-            WeakEventListener._cleanDeadReferences();
-        }
-
-        return listenerId;
-    }
-
-    static removeWeakEventListener(listenerId: number) {
-        var listenerRef = <WeakRef<WeakEventListener>>WeakEventListener._weakEventListeners[listenerId];
-
-        if (listenerRef) {
-            var listener = <WeakEventListener>listenerRef.get();
-            if (listener) {
-                listener.clear();
+function getHandlerForEventName(eventName: string): (eventData: observable.EventData) => void {
+    var handler = handlersForEventName.get(eventName);
+    if (!handler) {
+        var handler = function (eventData: observable.EventData) {
+            var source = eventData.object;
+            var sourceEventMap = sourcesMap.get(source);
+            if (!sourceEventMap) {
+                // There is no event map for this source - it is safe to detach the listener;
+                source.removeEventListener(eventName, handlersForEventName.get(eventName));
+                return;
             }
-        }
 
-        delete WeakEventListener._weakEventListeners[listenerId];
+            var targetHandlerPairList = sourceEventMap.get(eventName);
+            if (!targetHandlerPairList) {
+                return;
+            }
+
+            var deadPairsIndexes = [];
+            for (var i = 0; i < targetHandlerPairList.length; i++) {
+                var pair = targetHandlerPairList[i];
+
+                var target = pair.tagetRef.get();
+                if (target) {
+                    pair.handler.call(target, eventData);
+                }
+                else {
+                    deadPairsIndexes.push(i);
+                }
+            }
+
+            if (deadPairsIndexes.length === targetHandlerPairList.length) {
+                // There are no alive targets for this event - unsubscribe
+                source.removeEventListener(eventName, handlersForEventName.get(eventName));
+                sourceEventMap.delete(eventName);
+            }
+            else {
+                for (var j = deadPairsIndexes.length - 1; j >= 0; j--) {
+                    targetHandlerPairList.splice(deadPairsIndexes[j], 1);
+                }
+            }
+        };
+        handlersForEventName.set(eventName, handler);
     }
 
-    static _cleanDeadReferences() {
-        var deadListeners = new Array<number>();
-        for (var id in WeakEventListener._weakEventListeners) {
-            var listenerRef = <WeakRef<WeakEventListener>>WeakEventListener._weakEventListeners[id];
+    return handler;
+}
 
-            var listener = listenerRef.get();
-            if (!listener || !listener.targetRef.get() || !listener.senderRef.get()) {
-                deadListeners.push(id);
-            }
+function validateArgs(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) {
+    if (types.isNullOrUndefined(source)) {
+        throw new Error("source is null or undefined");
+    }
+
+    if (types.isNullOrUndefined(target)) {
+        throw new Error("target is null or undefined");
+    }
+
+    if (!types.isString(eventName)) {
+        throw new Error("eventName is not a string");
+    }
+
+    if (!types.isFunction(handler)) {
+        throw new Error("handler is not a function");
+    }
+}
+
+export function addWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) {
+    validateArgs(source, eventName, handler, target);
+
+    var sourceEventMap = sourcesMap.get(source);
+    if (!sourceEventMap) {
+        sourceEventMap = new Map<string, Array<TargetHandlerPair>>();
+        sourcesMap.set(source, sourceEventMap);
+    }
+
+    var pairList = sourceEventMap.get(eventName);
+    if (!pairList) {
+        pairList = new Array<TargetHandlerPair>();
+        sourceEventMap.set(eventName, pairList);
+    }
+
+    pairList.push(new TargetHandlerPair(target, handler));
+
+    source.addEventListener(eventName, getHandlerForEventName(eventName));
+}
+
+export function removeWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) {
+    validateArgs(source, eventName, handler, target);
+
+    var handlerForEventWithName = handlersForEventName.get(eventName);
+    if (!handlerForEventWithName) {
+        // We have never created handler for event with this name;
+        return;
+    }
+
+    var sourceEventMap = sourcesMap.get(source);
+    if (!sourceEventMap) {
+        return;
+    }
+
+    var targetHandlerPairList = sourceEventMap.get(eventName);
+    if (!targetHandlerPairList) {
+        return;
+    }
+
+    // Remove all pairs that match given target and handler or have a dead target
+    var targetHandlerPairsToRemove = [];
+    for (var i = 0; i < targetHandlerPairList.length; i++) {
+        var pair = targetHandlerPairList[i];
+
+        var registeredTarget = pair.tagetRef.get();
+        if (!registeredTarget || (registeredTarget === target && handler === pair.handler)) {
+            targetHandlerPairsToRemove.push(i);
         }
+    }
 
-        for (var i = 0; i < deadListeners.length; i++) {
-            WeakEventListener.removeWeakEventListener(deadListeners[i]);
+    if (targetHandlerPairsToRemove.length === targetHandlerPairList.length) {
+        // There are no alive targets for this event - unsubscribe
+        source.removeEventListener(eventName, handlerForEventWithName);
+        sourceEventMap.delete(eventName);
+    }
+    else {
+        for (var j = targetHandlerPairsToRemove.length - 1; j >= 0; j--) {
+            targetHandlerPairList.splice(targetHandlerPairsToRemove[j], 1);
         }
     }
 }
diff --git a/ui/list-view/list-view-common.ts b/ui/list-view/list-view-common.ts
index a5cc1ece5..f8cdc734f 100644
--- a/ui/list-view/list-view-common.ts
+++ b/ui/list-view/list-view-common.ts
@@ -7,7 +7,7 @@ import dependencyObservable = require("ui/core/dependency-observable");
 import builder = require("ui/builder");
 import label = require("ui/label");
 import color = require("color");
-import weakEventListener = require("ui/core/weak-event-listener");
+import weakEvents = require("ui/core/weak-event-listener");
 import types = require("utils/types");
 
 var ITEMS = "items";
@@ -132,17 +132,12 @@ export class ListView extends view.View implements definition.ListView {
 
     public _onItemsPropertyChanged(data: dependencyObservable.PropertyChangeData) {
         if (data.oldValue instanceof observable.Observable && types.isDefined(this._itemsChangedWeakListenerId)) {
-            weakEventListener.WeakEventListener.removeWeakEventListener(this._itemsChangedWeakListenerId);
+            weakEvents.removeWeakEventListener(data.oldValue, observableArray.ObservableArray.changeEvent, this._onItemsChanged, this);
             delete this._itemsChangedWeakListenerId;
         }
 
         if (data.newValue instanceof observable.Observable) {
-            this._itemsChangedWeakListenerId = weakEventListener.WeakEventListener.addWeakEventListener({
-                target: this,
-                source: data.newValue,
-                eventName: observableArray.ObservableArray.changeEvent,
-                handler: this._onItemsChanged,
-            });
+            weakEvents.addWeakEventListener(data.newValue, observableArray.ObservableArray.changeEvent, this._onItemsChanged, this);
         }
 
         this.refresh();
diff --git a/ui/text-base/text-base.ts b/ui/text-base/text-base.ts
index 1bf124d7f..77e77cefb 100644
--- a/ui/text-base/text-base.ts
+++ b/ui/text-base/text-base.ts
@@ -4,7 +4,7 @@ import observable = require("data/observable");
 import dependencyObservable = require("ui/core/dependency-observable");
 import proxy = require("ui/core/proxy");
 import formattedString = require("text/formatted-string");
-import weakEventListener = require("ui/core/weak-event-listener");
+import weakEvents = require("ui/core/weak-event-listener");
 import utils = require("utils/utils");
 import trace = require("trace");
 
@@ -38,8 +38,6 @@ export class TextBase extends view.View implements definition.TextBase {
     public static textProperty = textProperty;
     public static formattedTextProperty = formattedTextProperty;
 
-    private _formattedTextChangedListenerId: number;
-
     constructor(options?: definition.Options) {
         super(options);
     }
@@ -80,17 +78,11 @@ export class TextBase extends view.View implements definition.TextBase {
     set formattedText(value: formattedString.FormattedString) {
         if (this.formattedText !== value) {
             if (this.formattedText) {
-                weakEventListener.WeakEventListener.removeWeakEventListener(this._formattedTextChangedListenerId);
-                delete this._formattedTextChangedListenerId;
+                weakEvents.removeWeakEventListener(this.formattedText, observable.Observable.propertyChangeEvent, this.onFormattedTextChanged, this);
             }
             this._setValue(TextBase.formattedTextProperty, value);
             if (value) {
-                this._formattedTextChangedListenerId = weakEventListener.WeakEventListener.addWeakEventListener({
-                    target: this,
-                    source: value,
-                    eventName: observable.Observable.propertyChangeEvent,
-                    handler: this.onFormattedTextChanged,
-                });
+                weakEvents.addWeakEventListener(value, observable.Observable.propertyChangeEvent, this.onFormattedTextChanged, this);
             }
         }
     }

From c3aea99078556b97a22b12ecfb733aa72a04357a Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Fri, 15 May 2015 18:38:18 +0300
Subject: [PATCH 6/9] Tests - fixed

---
 apps/tests/ui/helper.ts                 |   7 +-
 apps/tests/weak-event-listener-tests.ts | 108 ++++++++++--------------
 ui/core/weak-event-listener.ts          |  11 ++-
 3 files changed, 59 insertions(+), 67 deletions(-)

diff --git a/apps/tests/ui/helper.ts b/apps/tests/ui/helper.ts
index ef59eb584..5b021bea4 100644
--- a/apps/tests/ui/helper.ts
+++ b/apps/tests/ui/helper.ts
@@ -175,7 +175,12 @@ export function buildUIWithWeakRefAndInteract<T extends view.View>(createFunc: (
             }
 
             sp.removeChild(weakRef.get());
-            forceGC();
+            if (newPage.ios) {
+                // Could cause GC on the next call.
+                // NOTE: Don't replace this with forceGC();
+                new ArrayBuffer(4 * 1024 * 1024);
+            }
+            utils.GC();
 
             TKUnit.assert(!weakRef.get(), weakRef.get() + " leaked!");
             testFinished = true;
diff --git a/apps/tests/weak-event-listener-tests.ts b/apps/tests/weak-event-listener-tests.ts
index 49524f1a0..c4108468d 100644
--- a/apps/tests/weak-event-listener-tests.ts
+++ b/apps/tests/weak-event-listener-tests.ts
@@ -1,5 +1,4 @@
 import TKUnit = require("./TKUnit");
-import types = require("utils/types");
 import observable = require("data/observable");
 import weakEvents = require("ui/core/weak-event-listener");
 import helper = require("./ui/helper");
@@ -53,6 +52,22 @@ export function test_addWeakEventListener_listensForEvent() {
     TKUnit.assertEqual(target.counter, 1, "Handler not called.");
 }
 
+export function test_addWeakEventListener_listensForEven_multipleTargetst() {
+    var source = new observable.Observable();
+    var target1 = new Target();
+    var target2 = new Target();
+
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target1.onEvent, target1);
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target2.onEvent, target2);
+
+    helper.forceGC();
+
+    source.set("testProp", "some value");
+
+    TKUnit.assertEqual(target1.counter, 1, "Handler not called.");
+    TKUnit.assertEqual(target2.counter, 1, "Handler not called.");
+}
+
 export function test_removeWeakEventListener_StopsListeningForEvet() {
     var source = new observable.Observable();
     var target = new Target();
@@ -66,7 +81,7 @@ export function test_removeWeakEventListener_StopsListeningForEvet() {
 
 export function test_handlerIsCalled_WithTargetAsThis() {
     var source = new observable.Observable();
-    var target = new Object;
+    var target = new Object();
     var callbackCalled = false;
     var handler = function (args: observable.EventData) {
         TKUnit.assertEqual(this, target, "this should be the target");
@@ -82,7 +97,6 @@ export function test_handlerIsCalled_WithTargetAsThis() {
 export function test_listnerDoesNotRetainTarget() {
     var source = new observable.Observable();
     var target = new Target();
-    var callbackCalled = false;
 
     weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target);
 
@@ -96,7 +110,6 @@ export function test_listnerDoesNotRetainTarget() {
 export function test_listnerDoesNotRetainSource() {
     var source = new observable.Observable();
     var target = new Target();
-    var callbackCalled = false;
 
     weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target);
 
@@ -107,74 +120,43 @@ export function test_listnerDoesNotRetainSource() {
     TKUnit.assert(!sourceRef.get(), "Source should be released after GC");
 }
 
-//export function test_listnerIsCleared_WhenTargetIsDead() {
-//    var source = new observable.Observable();
+export function test_handlerIsDetached_WhenAllListenersAreRemoved() {
+    var source = new observable.Observable();
 
-//    var listenerID = addListenerWithSource(source);
-//    helper.forceGC();
+    var target1 = new Target();
+    var target2 = new Target();
 
-//    for (var i = 0; i < weakEvents.cleanDeadReferencesCountTrigger; i++) {
-//        addListenerWithSource(source);
-//    }
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target1.onEvent, target1);
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target2.onEvent, target2);
 
-//    TKUnit.assert(types.isUndefined(weakEvents._weakEventListeners[listenerID]), "The first listener should be dead by now");
-//}
+    weakEvents.removeWeakEventListener(source, observable.Observable.propertyChangeEvent, target1.onEvent, target1)
+    weakEvents.removeWeakEventListener(source, observable.Observable.propertyChangeEvent, target2.onEvent, target2)
 
-//export function test_listnerIsCleared_WhenSourceIsDead() {
-//    var target = {};
+    TKUnit.assert(!source.hasListeners(observable.Observable.propertyChangeEvent), "All events should be detached");
+}
 
-//    var listenerID = addListenerWithTarget(target);
-//    helper.forceGC();
+export function test_autoDetachingOfDeadReferences() {
+    var source = new observable.Observable();
 
-//    for (var i = 0; i < weakEvents.cleanDeadReferencesCountTrigger; i++) {
-//        addListenerWithTarget(target);
-//    }
+    for (var i = 0; i < 100; i++) {
+        addListenerWithSource(source);
+    }
 
-//    TKUnit.assert(types.isUndefined(weakEvents._weakEventListeners[listenerID]), "The first listener should be dead by now");
-//}
+    helper.forceGC();
 
-//function addListenerWithSource(source: observable.Observable): number {
-//    return weakEvents.addWeakEventListener({
-//        source: source,
-//        target: {},
-//        handler: emptyHandler,
-//        eventName: observable.Observable.propertyChangeEvent
-//    })
-//}
+    var target = new Target();
 
-//function addListenerWithTarget(target: any): number {
-//    return weakEvents.addWeakEventListener({
-//        source: new observable.Observable(),
-//        target: target,
-//        handler: emptyHandler,
-//        eventName: observable.Observable.propertyChangeEvent
-//    })
-//}
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target);
+    weakEvents.removeWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target)
+
+    TKUnit.assert(!source.hasListeners(observable.Observable.propertyChangeEvent), "All events should be detached");
+}
+
+function addListenerWithSource(source: observable.Observable) {
+    var target = new Target();
+    weakEvents.addWeakEventListener(source, observable.Observable.propertyChangeEvent, target.onEvent, target)
+}
 
 function emptyHandler(data: observable.EventData) {
     // Do nothing.
-}
-
-
-
-export function testWeakMap(): void {
-    var source = new observable.Observable();
-    var target = new Target();
-    var targetRef = new WeakRef(target);
-    var weakMap = new WeakMap<observable.Observable, Target>();
-
-    weakMap.set(source, target);
-    TKUnit.assertEqual(weakMap.get(source), target, "target");
-
-    target = undefined;
-    source = undefined;
-
-    helper.forceGC();
-    TKUnit.wait(1);
-
-    TKUnit.waitUntilReady(function () {
-        return false;
-    })
-
-    TKUnit.assert(!targetRef.get(), "Target should be dead");
-}
+}
\ No newline at end of file
diff --git a/ui/core/weak-event-listener.ts b/ui/core/weak-event-listener.ts
index 886125964..245bc5fa6 100644
--- a/ui/core/weak-event-listener.ts
+++ b/ui/core/weak-event-listener.ts
@@ -1,5 +1,4 @@
 import observable = require("data/observable");
-import definition = require("ui/core/weak-event-listener");
 import types = require("utils/types");
 
 var handlersForEventName = new Map<string,(eventData: observable.EventData) => void>();
@@ -18,7 +17,7 @@ class TargetHandlerPair {
 function getHandlerForEventName(eventName: string): (eventData: observable.EventData) => void {
     var handler = handlersForEventName.get(eventName);
     if (!handler) {
-        var handler = function (eventData: observable.EventData) {
+        handler = function (eventData: observable.EventData) {
             var source = eventData.object;
             var sourceEventMap = sourcesMap.get(source);
             if (!sourceEventMap) {
@@ -83,21 +82,27 @@ function validateArgs(source: observable.Observable, eventName: string, handler:
 export function addWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) {
     validateArgs(source, eventName, handler, target);
 
+    var shouldAttach: boolean = false;
+
     var sourceEventMap = sourcesMap.get(source);
     if (!sourceEventMap) {
         sourceEventMap = new Map<string, Array<TargetHandlerPair>>();
         sourcesMap.set(source, sourceEventMap);
+        shouldAttach = true;
     }
 
     var pairList = sourceEventMap.get(eventName);
     if (!pairList) {
         pairList = new Array<TargetHandlerPair>();
         sourceEventMap.set(eventName, pairList);
+        shouldAttach = true;
     }
 
     pairList.push(new TargetHandlerPair(target, handler));
 
-    source.addEventListener(eventName, getHandlerForEventName(eventName));
+    if (shouldAttach) {
+        source.addEventListener(eventName, getHandlerForEventName(eventName));
+    }
 }
 
 export function removeWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) {

From 3cfaa221ae502c6ec9ea128e7b86b3a4a314c3c1 Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Mon, 18 May 2015 11:29:57 +0300
Subject: [PATCH 7/9] Clean unused variables

---
 ui/core/bindable.ts              | 1 -
 ui/core/weak-event-listener.d.ts | 4 ++--
 ui/list-view/list-view-common.ts | 5 +----
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/ui/core/bindable.ts b/ui/core/bindable.ts
index da860ac59..13fdc8de8 100644
--- a/ui/core/bindable.ts
+++ b/ui/core/bindable.ts
@@ -124,7 +124,6 @@ export class Binding {
     updating = false;
     source: WeakRef<Object>;
     target: WeakRef<Bindable>;
-    weakEventId: number;
 
     private sourceOptions: { instance: WeakRef<any>; property: any };
     private targetOptions: { instance: WeakRef<any>; property: any };
diff --git a/ui/core/weak-event-listener.d.ts b/ui/core/weak-event-listener.d.ts
index 450f04981..e1b843081 100644
--- a/ui/core/weak-event-listener.d.ts
+++ b/ui/core/weak-event-listener.d.ts
@@ -2,7 +2,7 @@ declare module "ui/core/weak-event-listener" {
     import observable = require("data/observable");
 
     /**
-     * Creates and initialize WeakEventListener.
+     * Attaches a WeakEventListener.
      * @param source Observable class which emits the event.
      * @param eventName The event name.
      * @param handler The function which should be called when event occurs.
@@ -11,7 +11,7 @@ declare module "ui/core/weak-event-listener" {
     export function addWeakEventListener(source: observable.Observable, eventName: string, handler: (eventData: observable.EventData) => void, target: any) : void;
 
     /**
-     * Removes and clears all resources from WeakEventListener.
+     * Removes a WeakEventListener.
      * @param source Observable class which emits the event.
      * @param eventName The event name.
      * @param handler The function which should be called when event occurs.
diff --git a/ui/list-view/list-view-common.ts b/ui/list-view/list-view-common.ts
index f8cdc734f..dad3b652f 100644
--- a/ui/list-view/list-view-common.ts
+++ b/ui/list-view/list-view-common.ts
@@ -69,8 +69,6 @@ export class ListView extends view.View implements definition.ListView {
             )
         );
 
-    private _itemsChangedWeakListenerId: number;
-
     get items(): any {
         return this._getValue(ListView.itemsProperty);
     }
@@ -131,9 +129,8 @@ export class ListView extends view.View implements definition.ListView {
     }
 
     public _onItemsPropertyChanged(data: dependencyObservable.PropertyChangeData) {
-        if (data.oldValue instanceof observable.Observable && types.isDefined(this._itemsChangedWeakListenerId)) {
+        if (data.oldValue instanceof observable.Observable)) {
             weakEvents.removeWeakEventListener(data.oldValue, observableArray.ObservableArray.changeEvent, this._onItemsChanged, this);
-            delete this._itemsChangedWeakListenerId;
         }
 
         if (data.newValue instanceof observable.Observable) {

From c3b687c880f64e79684565f8ecb08abec8306cc9 Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Mon, 18 May 2015 11:51:15 +0300
Subject: [PATCH 8/9] Ts lint

---
 ui/list-view/list-view-common.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/ui/list-view/list-view-common.ts b/ui/list-view/list-view-common.ts
index dad3b652f..6403e9ff6 100644
--- a/ui/list-view/list-view-common.ts
+++ b/ui/list-view/list-view-common.ts
@@ -8,7 +8,6 @@ import builder = require("ui/builder");
 import label = require("ui/label");
 import color = require("color");
 import weakEvents = require("ui/core/weak-event-listener");
-import types = require("utils/types");
 
 var ITEMS = "items";
 var ITEMTEMPLATE = "itemTemplate";
@@ -129,7 +128,7 @@ export class ListView extends view.View implements definition.ListView {
     }
 
     public _onItemsPropertyChanged(data: dependencyObservable.PropertyChangeData) {
-        if (data.oldValue instanceof observable.Observable)) {
+        if (data.oldValue instanceof observable.Observable) {
             weakEvents.removeWeakEventListener(data.oldValue, observableArray.ObservableArray.changeEvent, this._onItemsChanged, this);
         }
 

From 06c30f5693c009cb073596a9e8134c9029832f74 Mon Sep 17 00:00:00 2001
From: vakrilov <alexander.vakrilov@telerik.com>
Date: Mon, 18 May 2015 12:11:43 +0300
Subject: [PATCH 9/9] Skip unstable test in IOS

---
 apps/tests/timer-tests.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/apps/tests/timer-tests.ts b/apps/tests/timer-tests.ts
index 18d309db2..26e418a35 100644
--- a/apps/tests/timer-tests.ts
+++ b/apps/tests/timer-tests.ts
@@ -1,4 +1,5 @@
 import TKUnit = require("./TKUnit");
+import platform = require("platform");
 var timer = require("timer/timer");
 
 // <snippet module="timer" title="timer">
@@ -85,6 +86,12 @@ export var test_setTimeout_shouldReturnNumber = function () {
 };
 
 export var test_setTimeout_callbackShouldBeCleared = function () {
+    // This test is very unstable in iOS, because the platform does not guarantee the 
+    // callback will be cleared on time. Better skip it for iOS.
+    if (platform.device.os === platform.platformNames.ios) {
+        return;
+    }
+
     var completed: boolean;
     var isReady = function () { return completed; }